fixes documentation

.github/workflows/ci_docs.yml

@@ -45,7 +45,7 @@ jobs:
           - target: windows
             os: windows-2019
           - target: osx
-            os: macos-13
+            os: macos-12
 
     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,7 +17,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-20.04, macos-13]
+        os: [ubuntu-20.04, macos-12]
         cpu: [amd64]
         batch: ["allowed_failures", "0_3", "1_3", "2_3"] # list of `index_num`
     name: '${{ matrix.os }} (batch: ${{ matrix.batch }})'
@@ -49,7 +48,6 @@ jobs:
       - name: 'Install dependencies (macOS)'
         if: runner.os == 'macOS'
         run: brew install boehmgc make sfml gtk+3
-        # XXX can't find boehm and gtk on macos 13
       - name: 'Install dependencies (Windows)'
         if: runner.os == 'Windows'
         shell: bash

azure-pipelines.yml

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

build_all.bat

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

changelog.md

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

changelogs/changelog_2_2_0.md

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

changelogs/changelog_X_XX_X.md

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

compiler/ast.nim

@@ -491,7 +491,7 @@ type
     mAnd, mOr,
     mImplies, mIff, mExists, mForall, mOld,
     mEqStr, mLeStr, mLtStr,
-    mEqSet, mLeSet, mLtSet, mMulSet, mPlusSet, mMinusSet, mXorSet,
+    mEqSet, mLeSet, mLtSet, mMulSet, mPlusSet, mMinusSet,
     mConStrStr, mSlice,
     mDotDot, # this one is only necessary to give nice compile time warnings
     mFields, mFieldPairs, mOmpParFor,
@@ -559,7 +559,7 @@ const
     mStrToStr, mEnumToStr,
     mAnd, mOr,
     mEqStr, mLeStr, mLtStr,
-    mEqSet, mLeSet, mLtSet, mMulSet, mPlusSet, mMinusSet, mXorSet,
+    mEqSet, mLeSet, mLtSet, mMulSet, mPlusSet, mMinusSet,
     mConStrStr, mAppendStrCh, mAppendStrStr, mAppendSeqElem,
     mInSet, mRepr, mOpenArrayToSeq}
 
@@ -591,7 +591,7 @@ type
   TNode*{.final, acyclic.} = object # on a 32bit machine, this takes 32 bytes
     when defined(useNodeIds):
       id*: int
-    typField: PType
+    typ*: PType
     info*: TLineInfo
     flags*: TNodeFlags
     case kind*: TNodeKind
@@ -706,7 +706,7 @@ type
     when defined(nimsuggest):
       endInfo*: TLineInfo
       hasUserSpecifiedType*: bool  # used for determining whether to display inlay type hints
-    ownerField: PSym
+    owner*: PSym
     flags*: TSymFlags
     ast*: PNode               # syntax tree of proc, iterator, etc.:
                               # the whole proc including header; this is used
@@ -775,7 +775,7 @@ type
                               # formal param list
                               # for concepts, the concept body
                               # else: unused
-    ownerField: PSym          # the 'owner' of the type
+    owner*: PSym              # the 'owner' of the type
     sym*: PSym                # types have the sym associated with them
                               # it is used for converting types to strings
     size*: BiggestInt         # the size of the type in bytes
@@ -814,15 +814,6 @@ type
 
 template nodeId(n: PNode): int = cast[int](n)
 
-template typ*(n: PNode): PType =
-  n.typField
-
-proc owner*(s: PSym|PType): PSym {.inline.} =
-  result = s.ownerField
-
-proc setOwner*(s: PSym|PType, owner: PSym) {.inline.} =
-  s.ownerField = owner
-
 type Gconfig = object
   # we put comments in a side channel to avoid increasing `sizeof(TNode)`, which
   # reduces memory usage given that `PNode` is the most allocated type by far.
@@ -1141,7 +1132,7 @@ proc newNodeIT*(kind: TNodeKind, info: TLineInfo, typ: PType): PNode =
   ## new node with line info, type, and no children
   result = newNode(kind)
   result.info = info
-  result.typ() = typ
+  result.typ = typ
 
 proc newNode*(kind: TNodeKind, info: TLineInfo): PNode =
   ## new node with line info, no type, and no children
@@ -1206,7 +1197,7 @@ proc newSym*(symKind: TSymKind, name: PIdent, idgen: IdGenerator; owner: PSym,
   assert not name.isNil
   let id = nextSymId idgen
   result = PSym(name: name, kind: symKind, flags: {}, info: info, itemId: id,
-                options: options, ownerField: owner, offset: defaultOffset,
+                options: options, owner: owner, offset: defaultOffset,
                 disamb: getOrDefault(idgen.disambTable, name).int32)
   idgen.disambTable.inc name
   when false:
@@ -1287,13 +1278,13 @@ proc newIdentNode*(ident: PIdent, info: TLineInfo): PNode =
 proc newSymNode*(sym: PSym): PNode =
   result = newNode(nkSym)
   result.sym = sym
-  result.typ() = sym.typ
+  result.typ = sym.typ
   result.info = sym.info
 
 proc newSymNode*(sym: PSym, info: TLineInfo): PNode =
   result = newNode(nkSym)
   result.sym = sym
-  result.typ() = sym.typ
+  result.typ = sym.typ
   result.info = info
 
 proc newOpenSym*(n: PNode): PNode {.inline.} =
@@ -1373,7 +1364,7 @@ proc newIntTypeNode*(intVal: BiggestInt, typ: PType): PNode =
     result = newNode(nkIntLit)
   else: raiseAssert $kind
   result.intVal = intVal
-  result.typ() = typ
+  result.typ = typ
 
 proc newIntTypeNode*(intVal: Int128, typ: PType): PNode =
   # XXX: introduce range check
@@ -1512,7 +1503,7 @@ iterator signature*(t: PType): PType =
 
 proc newType*(kind: TTypeKind; idgen: IdGenerator; owner: PSym; son: sink PType = nil): PType =
   let id = nextTypeId idgen
-  result = PType(kind: kind, ownerField: owner, size: defaultSize,
+  result = PType(kind: kind, owner: owner, size: defaultSize,
                  align: defaultAlignment, itemId: id,
                  uniqueId: id, sons: @[])
   if son != nil: result.sons.add son
@@ -1567,7 +1558,7 @@ proc copyType*(t: PType, idgen: IdGenerator, owner: PSym): PType =
   result.sym = t.sym          # backend-info should not be copied
 
 proc exactReplica*(t: PType): PType =
-  result = PType(kind: t.kind, ownerField: t.owner, size: defaultSize,
+  result = PType(kind: t.kind, owner: t.owner, size: defaultSize,
                  align: defaultAlignment, itemId: t.itemId,
                  uniqueId: t.uniqueId)
   assignType(result, t)
@@ -1645,7 +1636,7 @@ proc propagateToOwner*(owner, elem: PType; propagateHasAsgn = true) =
   if mask != {} and propagateHasAsgn:
     let o2 = owner.skipTypes({tyGenericInst, tyAlias, tySink})
     if o2.kind in {tyTuple, tyObject, tyArray,
-                   tySequence, tyString, tySet, tyDistinct}:
+                   tySequence, tySet, tyDistinct}:
       o2.flags.incl mask
       owner.flags.incl mask
 
@@ -1675,7 +1666,7 @@ proc copyNode*(src: PNode): PNode =
     return nil
   result = newNode(src.kind)
   result.info = src.info
-  result.typ() = src.typ
+  result.typ = src.typ
   result.flags = src.flags * PersistentNodeFlags
   result.comment = src.comment
   when defined(useNodeIds):
@@ -1693,7 +1684,7 @@ proc copyNode*(src: PNode): PNode =
 
 template transitionNodeKindCommon(k: TNodeKind) =
   let obj {.inject.} = n[]
-  n[] = TNode(kind: k, typField: n.typ, info: obj.info, flags: obj.flags)
+  n[] = TNode(kind: k, typ: obj.typ, info: obj.info, flags: obj.flags)
   # n.comment = obj.comment # shouldn't be needed, the address doesnt' change
   when defined(useNodeIds):
     n.id = obj.id
@@ -1716,7 +1707,7 @@ proc transitionNoneToSym*(n: PNode) =
 template transitionSymKindCommon*(k: TSymKind) =
   let obj {.inject.} = s[]
   s[] = TSym(kind: k, itemId: obj.itemId, magic: obj.magic, typ: obj.typ, name: obj.name,
-             info: obj.info, ownerField: obj.ownerField, flags: obj.flags, ast: obj.ast,
+             info: obj.info, owner: obj.owner, flags: obj.flags, ast: obj.ast,
              options: obj.options, position: obj.position, offset: obj.offset,
              loc: obj.loc, annex: obj.annex, constraint: obj.constraint)
   when hasFFI:
@@ -1744,7 +1735,7 @@ template copyNodeImpl(dst, src, processSonsStmt) =
   dst.info = src.info
   when defined(nimsuggest):
     result.endInfo = src.endInfo
-  dst.typ() = src.typ
+  dst.typ = src.typ
   dst.flags = src.flags * PersistentNodeFlags
   dst.comment = src.comment
   when defined(useNodeIds):
@@ -1902,7 +1893,7 @@ proc skipGenericOwner*(s: PSym): PSym =
 
 proc originatingModule*(s: PSym): PSym =
   result = s
-  while result != nil and result.kind != skModule: result = result.owner
+  while result.kind != skModule: result = result.owner
 
 proc isRoutine*(s: PSym): bool {.inline.} =
   result = s.kind in skProcKinds

compiler/cbuilderbase.nim

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

compiler/cbuilderdecls.nim

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

compiler/cbuilderexprs.nim

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

compiler/cbuilderstmts.nim

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

compiler/ccgcalls.nim

@@ -209,7 +209,8 @@ proc genOpenArraySlice(p: BProc; q: PNode; formalType, destType: PType; prepareF
       result = ("($3*)(($1)+($2))" % [rdLoc(a), rdLoc(b), dest],
                 lengthExpr)
     else:
-      let lit = cIntLiteral(first)
+      var lit = newRopeAppender()
+      intLiteral(first, lit)
       result = ("($4*)($1)+(($2)-($3))" %
         [rdLoc(a), rdLoc(b), lit, dest],
         lengthExpr)
@@ -335,7 +336,7 @@ proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Rope; need
     # 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 = n.typ.exactReplica
       n.typ.flags.incl tfVarIsPtr
     a = initLocExprSingleUse(p, n)
     a = withTmpIfNeeded(p, a, needsTmp)

compiler/ccgliterals.nim

@@ -36,84 +36,52 @@ proc genStringLiteralDataOnlyV1(m: BModule, s: string; result: var Rope) =
   cgsym(m, "TGenericSeq")
   let tmp = getTempName(m)
   result.add tmp
-  var res = newBuilder("")
-  res.addVarWithTypeAndInitializer(AlwaysConst, name = tmp):
-    res.addSimpleStruct(m, name = "", baseType = ""):
-      res.addField(name = "Sup", typ = "TGenericSeq")
-      res.addArrayField(name = "data", elementType = "NIM_CHAR", len = s.len + 1)
-  do:
-    var strInit: StructInitializer
-    res.addStructInitializer(strInit, kind = siOrderedStruct):
-      res.addField(strInit, name = "Sup"):
-        var seqInit: StructInitializer
-        res.addStructInitializer(seqInit, kind = siOrderedStruct):
-          res.addField(seqInit, name = "len"):
-            res.addIntValue(s.len)
-          res.addField(seqInit, name = "reserved"):
-            res.add(cCast("NI", bitOr(cCast("NU", rope(s.len)), "NIM_STRLIT_FLAG")))
-      res.addField(strInit, name = "data"):
-        res.add(makeCString(s))
-  m.s[cfsStrData].add(extract(res))
+  m.s[cfsStrData].addf("STRING_LITERAL($1, $2, $3);$n",
+       [tmp, makeCString(s), rope(s.len)])
 
-proc genStringLiteralV1(m: BModule; n: PNode; result: var Builder) =
+proc genStringLiteralV1(m: BModule; n: PNode; result: var Rope) =
   if s.isNil:
-    result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), "NIM_NIL"))
+    appcg(m, result, "((#NimStringDesc*) NIM_NIL)", [])
   else:
     let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
-    var name: string = ""
     if id == m.labels:
       # string literal not found in the cache:
-      genStringLiteralDataOnlyV1(m, n.strVal, name)
+      appcg(m, result, "((#NimStringDesc*) &", [])
+      genStringLiteralDataOnlyV1(m, n.strVal, result)
+      result.add ")"
     else:
-      name = m.tmpBase & $id
-    result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), cAddr(name)))
+      appcg(m, result, "((#NimStringDesc*) &$1$2)",
+                      [m.tmpBase, id])
 
 # ------ Version 2: destructor based strings and seqs -----------------------
 
 proc genStringLiteralDataOnlyV2(m: BModule, s: string; result: Rope; isConst: bool) =
-  var res = newBuilder("")
-  res.addVarWithTypeAndInitializer(
-      if isConst: AlwaysConst else: Global,
-      name = result):
-    res.addSimpleStruct(m, name = "", baseType = ""):
-      res.addField(name = "cap", typ = "NI")
-      res.addArrayField(name = "data", elementType = "NIM_CHAR", len = s.len + 1)
-  do:
-    var structInit: StructInitializer
-    res.addStructInitializer(structInit, kind = siOrderedStruct):
-      res.addField(structInit, name = "cap"):
-        res.add(bitOr(rope(s.len), "NIM_STRLIT_FLAG"))
-      res.addField(structInit, name = "data"):
-        res.add(makeCString(s))
-  m.s[cfsStrData].add(extract(res))
+  m.s[cfsStrData].addf("static $4 struct {$n" &
+       "  NI cap; NIM_CHAR data[$2+1];$n" &
+       "} $1 = { $2 | NIM_STRLIT_FLAG, $3 };$n",
+       [result, rope(s.len), makeCString(s),
+       rope(if isConst: "const" else: "")])
 
-proc genStringLiteralV2(m: BModule; n: PNode; isConst: bool; result: var Builder) =
+proc genStringLiteralV2(m: BModule; n: PNode; isConst: bool; result: var Rope) =
   let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
-  var litName: string
   if id == m.labels:
+    let pureLit = getTempName(m)
+    genStringLiteralDataOnlyV2(m, n.strVal, pureLit, isConst)
+    let tmp = getTempName(m)
+    result.add tmp
     cgsym(m, "NimStrPayload")
     cgsym(m, "NimStringV2")
     # string literal not found in the cache:
-    litName = getTempName(m)
-    genStringLiteralDataOnlyV2(m, n.strVal, litName, isConst)
+    m.s[cfsStrData].addf("static $4 NimStringV2 $1 = {$2, (NimStrPayload*)&$3};$n",
+          [tmp, rope(n.strVal.len), pureLit, rope(if isConst: "const" else: "")])
   else:
-    litName = m.tmpBase & $id
-  let tmp = getTempName(m)
-  result.add tmp
-  var res = newBuilder("")
-  res.addVarWithInitializer(
-      if isConst: AlwaysConst else: Global,
-      name = tmp,
-      typ = "NimStringV2"):
-    var strInit: StructInitializer
-    res.addStructInitializer(strInit, kind = siOrderedStruct):
-      res.addField(strInit, name = "len"):
-        res.addIntValue(n.strVal.len)
-      res.addField(strInit, name = "p"):
-        res.add(cCast(ptrType("NimStrPayload"), cAddr(litName)))
-  m.s[cfsStrData].add(extract(res))
+    let tmp = getTempName(m)
+    result.add tmp
+    m.s[cfsStrData].addf("static $4 NimStringV2 $1 = {$2, (NimStrPayload*)&$3};$n",
+          [tmp, rope(n.strVal.len), m.tmpBase & rope(id),
+          rope(if isConst: "const" else: "")])
 
-proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Builder) =
+proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Rope) =
   let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
   var pureLit: Rope
   if id == m.labels:
@@ -124,12 +92,7 @@ proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Bu
     genStringLiteralDataOnlyV2(m, n.strVal, pureLit, isConst)
   else:
     pureLit = m.tmpBase & rope(id)
-  var strInit: StructInitializer
-  result.addStructInitializer(strInit, kind = siOrderedStruct):
-    result.addField(strInit, name = "len"):
-      result.addIntValue(n.strVal.len)
-    result.addField(strInit, name = "p"):
-      result.add(cCast(ptrType("NimStrPayload"), cAddr(pureLit)))
+  result.addf "{$1, (NimStrPayload*)&$2}", [rope(n.strVal.len), pureLit]
 
 # ------ Version selector ---------------------------------------------------
 
@@ -144,10 +107,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")), "NIM_NIL"))
+proc genNilStringLiteral(m: BModule; info: TLineInfo; result: var Rope) =
+  appcg(m, result, "((#NimStringDesc*) NIM_NIL)", [])
 
-proc genStringLiteral(m: BModule; n: PNode; result: var Builder) =
+proc genStringLiteral(m: BModule; n: PNode; result: var Rope) =
   case detectStrVersion(m)
   of 0, 1: genStringLiteralV1(m, n, result)
   of 2: genStringLiteralV2(m, n, isConst = true, result)

compiler/ccgstmts.nim

@@ -146,16 +146,16 @@ proc loadInto(p: BProc, le, ri: PNode, a: var TLoc) {.inline.} =
     a.flags.incl(lfEnforceDeref)
     expr(p, ri, a)
 
-proc assignLabel(b: var TBlock; result: var Builder) {.inline.} =
+proc assignLabel(b: var TBlock; result: var Rope) {.inline.} =
   b.label = "LA" & b.id.rope
   result.add b.label
 
-proc blockBody(b: var TBlock; result: var Builder) =
-  result.add extract(b.sections[cpsLocals])
+proc blockBody(b: var TBlock; result: var Rope) =
+  result.add b.sections[cpsLocals]
   if b.frameLen > 0:
     result.addf("FR_.len+=$1;$n", [b.frameLen.rope])
-  result.add(extract(b.sections[cpsInit]))
-  result.add(extract(b.sections[cpsStmts]))
+  result.add(b.sections[cpsInit])
+  result.add(b.sections[cpsStmts])
 
 proc endBlock(p: BProc, blockEnd: Rope) =
   let topBlock = p.blocks.len-1
@@ -279,9 +279,9 @@ proc genGotoVar(p: BProc; value: PNode) =
   else:
     lineF(p, cpsStmts, "goto NIMSTATE_$#;$n", [value.intVal.rope])
 
-proc genBracedInit(p: BProc, n: PNode; isConst: bool; optionalType: PType; result: var Builder)
+proc genBracedInit(p: BProc, n: PNode; isConst: bool; optionalType: PType; result: var Rope)
 
-proc potentialValueInit(p: BProc; v: PSym; value: PNode; result: var Builder) =
+proc potentialValueInit(p: BProc; v: PSym; value: PNode; result: var Rope) =
   if lfDynamicLib in v.loc.flags or sfThread in v.flags or p.hcrOn:
     discard "nothing to do"
   elif sfGlobal in v.flags and value != nil and isDeepConstExpr(value, p.module.compileToCpp) and
@@ -330,9 +330,8 @@ proc genSingleVar(p: BProc, v: PSym; vn, value: PNode) =
     value.kind in nkCallKinds and value[0].kind == nkSym and
     v.typ.kind != tyPtr and sfConstructor in value[0].sym.flags
   var targetProc = p
-  var valueBuilder = newBuilder("")
-  potentialValueInit(p, v, value, valueBuilder)
-  let valueAsRope = extract(valueBuilder)
+  var valueAsRope = ""
+  potentialValueInit(p, v, value, valueAsRope)
   if sfGlobal in v.flags:
     if v.flags * {sfImportc, sfExportc} == {sfImportc} and
         value.kind == nkEmpty and
@@ -595,7 +594,8 @@ proc genComputedGoto(p: BProc; n: PNode) =
         return
 
       let val = getOrdValue(it[j])
-      let lit = cIntLiteral(toInt64(val)+id+1)
+      var lit = newRopeAppender()
+      intLiteral(toInt64(val)+id+1, lit)
       lineF(p, cpsStmts, "TMP$#_:$n", [lit])
 
     genStmts(p, it.lastSon)
@@ -775,7 +775,7 @@ proc finallyActions(p: BProc) =
     if finallyBlock != nil:
       genSimpleBlock(p, finallyBlock[0])
 
-proc raiseInstr(p: BProc; result: var Builder) =
+proc raiseInstr(p: BProc; result: var Rope) =
   if p.config.exc == excGoto:
     let L = p.nestedTryStmts.len
     if L == 0:
@@ -925,7 +925,8 @@ proc genStringCase(p: BProc, t: PNode, stringKind: TTypeKind, d: var TLoc) =
               [rdLoc(a), bitMask])
     for j in 0..high(branches):
       if branches[j] != "":
-        let lit = cIntLiteral(j)
+        var lit = newRopeAppender()
+        intLiteral(j, lit)
         lineF(p, cpsStmts, "case $1: $n$2break;$n",
              [lit, branches[j]])
     lineF(p, cpsStmts, "}$n", []) # else statement:
@@ -963,22 +964,22 @@ proc genCaseRange(p: BProc, branch: PNode) =
   for j in 0..<branch.len-1:
     if branch[j].kind == nkRange:
       if hasSwitchRange in CC[p.config.cCompiler].props:
-        var litA = newBuilder("")
-        var litB = newBuilder("")
+        var litA = newRopeAppender()
+        var litB = newRopeAppender()
         genLiteral(p, branch[j][0], litA)
         genLiteral(p, branch[j][1], litB)
-        lineF(p, cpsStmts, "case $1 ... $2:$n", [extract(litA), extract(litB)])
+        lineF(p, cpsStmts, "case $1 ... $2:$n", [litA, litB])
       else:
         var v = copyNode(branch[j][0])
         while v.intVal <= branch[j][1].intVal:
-          var litA = newBuilder("")
+          var litA = newRopeAppender()
           genLiteral(p, v, litA)
-          lineF(p, cpsStmts, "case $1:$n", [extract(litA)])
+          lineF(p, cpsStmts, "case $1:$n", [litA])
           inc(v.intVal)
     else:
-      var litA = newBuilder("")
+      var litA = newRopeAppender()
       genLiteral(p, branch[j], litA)
-      lineF(p, cpsStmts, "case $1:$n", [extract(litA)])
+      lineF(p, cpsStmts, "case $1:$n", [litA])
 
 proc genOrdinalCase(p: BProc, n: PNode, d: var TLoc) =
   # analyse 'case' statement:
@@ -1640,7 +1641,8 @@ proc genDiscriminantCheck(p: BProc, a, tmp: TLoc, objtype: PType,
   if not containsOrIncl(p.module.declaredThings, field.id):
     appcg(p.module, cfsVars, "extern $1",
           [discriminatorTableDecl(p.module, t, field)])
-  let lit = cIntLiteral(toInt64(lengthOrd(p.config, field.typ))+1)
+  var lit = newRopeAppender()
+  intLiteral(toInt64(lengthOrd(p.config, field.typ))+1, lit)
   lineCg(p, cpsStmts,
         "#FieldDiscriminantCheck((NI)(NU)($1), (NI)(NU)($2), $3, $4);$n",
         [rdLoc(a), rdLoc(tmp), discriminatorTableName(p.module, t, field),

compiler/ccgthreadvars.nim

@@ -47,9 +47,7 @@ proc generateThreadLocalStorage(m: BModule) =
   if m.g.nimtv != "" and (usesThreadVars in m.flags or sfMainModule in m.module.flags):
     for t in items(m.g.nimtvDeps): discard getTypeDesc(m, t)
     finishTypeDescriptions(m)
-    m.s[cfsSeqTypes].addTypedef(name = "NimThreadVars"):
-      m.s[cfsSeqTypes].addSimpleStruct(m, name = "", baseType = ""):
-        m.s[cfsSeqTypes].add(m.g.nimtv)
+    m.s[cfsSeqTypes].addf("typedef struct {$1} NimThreadVars;$n", [m.g.nimtv])
 
 proc generateThreadVarsSize(m: BModule) =
   if m.g.nimtv != "":

compiler/ccgtrav.nim

@@ -76,11 +76,12 @@ 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)
+    freeze oldCode
     linefmt(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n",
             [i.snippet, arraySize])
-    let oldLen = p.s(cpsStmts).buf.len
+    let oldLen = p.s(cpsStmts).len
     genTraverseProc(c, ropecg(c.p.module, "$1[$2]", [accessor, i.snippet]), typ.elementType)
-    if p.s(cpsStmts).buf.len == oldLen:
+    if p.s(cpsStmts).len == oldLen:
       # do not emit dummy long loops for faster debug builds:
       p.s(cpsStmts) = oldCode
     else:
@@ -118,13 +119,14 @@ 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)
+  freeze oldCode
   var a = TLoc(snippet: accessor)
 
   lineF(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n",
       [i.snippet, lenExpr(c.p, a)])
-  let oldLen = p.s(cpsStmts).buf.len
+  let oldLen = p.s(cpsStmts).len
   genTraverseProc(c, "$1$3[$2]" % [accessor, i.snippet, dataField(c.p)], typ.elementType)
-  if p.s(cpsStmts).buf.len == oldLen:
+  if p.s(cpsStmts).len == oldLen:
     # do not emit dummy long loops for faster debug builds:
     p.s(cpsStmts) = oldCode
   else:
@@ -158,7 +160,7 @@ proc genTraverseProc(m: BModule, origTyp: PType; sig: SigHash): Rope =
       genTraverseProc(c, "(*a)".rope, typ.elementType)
 
   let generatedProc = "$1 {$n$2$3$4}\n" %
-        [header, extract(p.s(cpsLocals)), extract(p.s(cpsInit)), extract(p.s(cpsStmts))]
+        [header, p.s(cpsLocals), p.s(cpsInit), p.s(cpsStmts)]
 
   m.s[cfsProcHeaders].addf("$1;\n", [header])
   m.s[cfsProcs].add(generatedProc)
@@ -187,7 +189,7 @@ proc genTraverseProcForGlobal(m: BModule, s: PSym; info: TLineInfo): Rope =
   genTraverseProc(c, sLoc, s.loc.t)
 
   let generatedProc = "$1 {$n$2$3$4}$n" %
-        [header, extract(p.s(cpsLocals)), extract(p.s(cpsInit)), extract(p.s(cpsStmts))]
+        [header, p.s(cpsLocals), p.s(cpsInit), p.s(cpsStmts)]
 
   m.s[cfsProcHeaders].addf("$1;$n", [header])
   m.s[cfsProcs].add(generatedProc)

compiler/cgen.nim

@@ -14,9 +14,9 @@ import
   nversion, nimsets, msgs, bitsets, idents, types,
   ccgutils, ropes, wordrecg, treetab, cgmeth,
   rodutils, renderer, cgendata, aliases,
-  lowerings, lineinfos, pathutils, transf,
+  lowerings, ndi, lineinfos, pathutils, transf,
   injectdestructors, astmsgs, modulepaths, pushpoppragmas,
-  mangleutils, cbuilderbase
+  mangleutils
 
 from expanddefaults import caseObjDefaultBranch
 
@@ -97,7 +97,7 @@ proc t(a: TLoc): PType {.inline.} =
 
 proc lodeTyp(t: PType): PNode =
   result = newNode(nkEmpty)
-  result.typ() = t
+  result.typ = t
 
 proc isSimpleConst(typ: PType): bool =
   let t = skipTypes(typ, abstractVar)
@@ -138,9 +138,6 @@ proc cgFormatValue(result: var string; value: BiggestInt) =
 proc cgFormatValue(result: var string; value: Int128) =
   result.addInt128 value
 
-template addf(result: var Builder, args: varargs[untyped]) =
-  result.buf.addf(args)
-
 # TODO: please document
 macro ropecg(m: BModule, frmt: static[FormatStr], args: untyped): Rope =
   args.expectKind nnkBracket
@@ -240,15 +237,7 @@ proc addIndent(p: BProc; result: var Rope) =
     result[i] = '\t'
     inc i
 
-proc addIndent(p: BProc; result: var Builder) =
-  var i = result.buf.len
-  let newLen = i + p.blocks.len
-  result.buf.setLen newLen
-  while i < newLen:
-    result.buf[i] = '\t'
-    inc i
-
-template appcg(m: BModule, c: var (Rope | Builder), frmt: FormatStr,
+template appcg(m: BModule, c: var Rope, frmt: FormatStr,
            args: untyped) =
   c.add(ropecg(m, frmt, args))
 
@@ -286,7 +275,7 @@ proc safeLineNm(info: TLineInfo): int =
 proc genPostprocessDir(field1, field2, field3: string): string =
   result = postprocessDirStart & field1 & postprocessDirSep & field2 & postprocessDirSep & field3 & postprocessDirEnd
 
-proc genCLineDir(r: var Builder, fileIdx: FileIndex, line: int; conf: ConfigRef) =
+proc genCLineDir(r: var Rope, fileIdx: FileIndex, line: int; conf: ConfigRef) =
   assert line >= 0
   if optLineDir in conf.options and line > 0:
     if fileIdx == InvalidFileIdx:
@@ -294,7 +283,7 @@ proc genCLineDir(r: var Builder, fileIdx: FileIndex, line: int; conf: ConfigRef)
     else:
       r.add(rope("\n#line " & $line & " FX_" & $fileIdx.int32 & "\n"))
 
-proc genCLineDir(r: var Builder, fileIdx: FileIndex, line: int; p: BProc; info: TLineInfo; lastFileIndex: FileIndex) =
+proc genCLineDir(r: var Rope, fileIdx: FileIndex, line: int; p: BProc; info: TLineInfo; lastFileIndex: FileIndex) =
   assert line >= 0
   if optLineDir in p.config.options and line > 0:
     if fileIdx == InvalidFileIdx:
@@ -302,7 +291,7 @@ proc genCLineDir(r: var Builder, fileIdx: FileIndex, line: int; p: BProc; info:
     else:
       r.add(rope("\n#line " & $line & " FX_" & $fileIdx.int32 & "\n"))
 
-proc genCLineDir(r: var Builder, info: TLineInfo; conf: ConfigRef) =
+proc genCLineDir(r: var Rope, info: TLineInfo; conf: ConfigRef) =
   if optLineDir in conf.options:
     genCLineDir(r, info.fileIndex, info.safeLineNm, conf)
 
@@ -315,7 +304,7 @@ proc freshLineInfo(p: BProc; info: TLineInfo): bool =
   else:
     result = false
 
-proc genCLineDir(r: var Builder, p: BProc, info: TLineInfo; conf: ConfigRef) =
+proc genCLineDir(r: var Rope, p: BProc, info: TLineInfo; conf: ConfigRef) =
   if optLineDir in conf.options:
     let lastFileIndex = p.lastLineInfo.fileIndex
     if freshLineInfo(p, info):
@@ -339,7 +328,7 @@ proc genLineDir(p: BProc, t: PNode) =
 proc accessThreadLocalVar(p: BProc, s: PSym)
 proc emulatedThreadVars(conf: ConfigRef): bool {.inline.}
 proc genProc(m: BModule, prc: PSym)
-proc raiseInstr(p: BProc; result: var Builder)
+proc raiseInstr(p: BProc; result: var Rope)
 
 template compileToCpp(m: BModule): untyped =
   m.config.backend == backendCpp or sfCompileToCpp in m.module.flags
@@ -348,45 +337,31 @@ proc getTempName(m: BModule): Rope =
   result = m.tmpBase & rope(m.labels)
   inc m.labels
 
-proc isNoReturn(m: BModule; s: PSym): bool {.inline.} =
-  sfNoReturn in s.flags and m.config.exc != excGoto
-
-include cbuilderexprs
-include cbuilderdecls
-include cbuilderstmts
-
 proc rdLoc(a: TLoc): Rope =
   # 'read' location (deref if indirect)
   if lfIndirect in a.flags:
-    result = cDeref(a.snippet)
+    result = "(*" & a.snippet & ")"
   else:
     result = a.snippet
 
 proc addRdLoc(a: TLoc; result: var Rope) =
   if lfIndirect in a.flags:
-    result.add cDeref(a.snippet)
+    result.add "(*" & a.snippet & ")"
   else:
     result.add a.snippet
 
 proc lenField(p: BProc): Rope {.inline.} =
   result = rope(if p.module.compileToCpp: "len" else: "Sup.len")
 
-proc lenField(p: BProc, val: Rope): Rope {.inline.} =
-  if p.module.compileToCpp:
-    result = derefField(val, "len")
-  else:
-    result = dotField(derefField(val, "Sup"), "len")
-
 proc lenExpr(p: BProc; a: TLoc): Rope =
   if optSeqDestructors in p.config.globalOptions:
-    result = dotField(rdLoc(a), "len")
+    result = rdLoc(a) & ".len"
   else:
-    let ra = rdLoc(a)
-    result = cIfExpr(ra, lenField(p, ra), cIntValue(0))
+    result = "($1 ? $1->$2 : 0)" % [rdLoc(a), lenField(p)]
 
 proc dataFieldAccessor(p: BProc, sym: Rope): Rope =
   if optSeqDestructors in p.config.globalOptions:
-    result = dotField(wrapPar(sym), "p")
+    result = "(" & sym & ").p"
   else:
     result = sym
 
@@ -396,9 +371,6 @@ proc dataField(p: BProc): Rope =
   else:
     result = rope"->data"
 
-proc dataField(p: BProc, val: Rope): Rope {.inline.} =
-  result = derefField(dataFieldAccessor(p, val), "data")
-
 proc genProcPrototype(m: BModule, sym: PSym)
 
 include ccgliterals
@@ -413,20 +385,20 @@ template mapTypeChooser(a: TLoc): TSymKind = mapTypeChooser(a.lode)
 
 proc addAddrLoc(conf: ConfigRef; a: TLoc; result: var Rope) =
   if lfIndirect notin a.flags and mapType(conf, a.t, mapTypeChooser(a) == skParam) != ctArray:
-    result.add wrapPar(cAddr(a.snippet))
+    result.add "(&" & a.snippet & ")"
   else:
     result.add a.snippet
 
 proc addrLoc(conf: ConfigRef; a: TLoc): Rope =
   if lfIndirect notin a.flags and mapType(conf, a.t, mapTypeChooser(a) == skParam) != ctArray:
-    result = wrapPar(cAddr(a.snippet))
+    result = "(&" & a.snippet & ")"
   else:
     result = a.snippet
 
 proc byRefLoc(p: BProc; a: TLoc): Rope =
   if lfIndirect notin a.flags and mapType(p.config, a.t, mapTypeChooser(a) == skParam) != ctArray and not
       p.module.compileToCpp:
-    result = wrapPar(cAddr(a.snippet))
+    result = "(&" & a.snippet & ")"
   else:
     result = a.snippet
 
@@ -434,7 +406,7 @@ proc rdCharLoc(a: TLoc): Rope =
   # read a location that may need a char-cast:
   result = rdLoc(a)
   if skipTypes(a.t, abstractRange).kind == tyChar:
-    result = cCast("NU8", result)
+    result = "((NU8)($1))" % [result]
 
 type
   TAssignmentFlag = enum
@@ -623,29 +595,28 @@ proc getIntTemp(p: BProc): TLoc =
   linefmt(p, cpsLocals, "NI $1;$n", [result.snippet])
 
 proc localVarDecl(p: BProc; n: PNode): Rope =
-  var res = newBuilder("")
+  result = ""
   let s = n.sym
   if s.loc.k == locNone:
     fillLocalName(p, s)
     fillLoc(s.loc, locLocalVar, n, OnStack)
     if s.kind == skLet: incl(s.loc.flags, lfNoDeepCopy)
   if s.kind in {skLet, skVar, skField, skForVar} and s.alignment > 0:
-    res.addf("NIM_ALIGN($1) ", [rope(s.alignment)])
+    result.addf("NIM_ALIGN($1) ", [rope(s.alignment)])
 
-  genCLineDir(res, p, n.info, p.config)
+  genCLineDir(result, p, n.info, p.config)
 
-  res.add getTypeDesc(p.module, s.typ, dkVar)
+  result.add getTypeDesc(p.module, s.typ, dkVar)
   if sfCodegenDecl notin s.flags:
-    if sfRegister in s.flags: res.add(" register")
+    if sfRegister in s.flags: result.add(" register")
     #elif skipTypes(s.typ, abstractInst).kind in GcTypeKinds:
     #  decl.add(" GC_GUARD")
-    if sfVolatile in s.flags: res.add(" volatile")
-    if sfNoalias in s.flags: res.add(" NIM_NOALIAS")
-    res.add(" ")
-    res.add(s.loc.snippet)
-    result = extract(res)
+    if sfVolatile in s.flags: result.add(" volatile")
+    if sfNoalias in s.flags: result.add(" NIM_NOALIAS")
+    result.add(" ")
+    result.add(s.loc.snippet)
   else:
-    result = runtimeFormat(s.cgDeclFrmt, [extract(res), s.loc.snippet])
+    result = runtimeFormat(s.cgDeclFrmt, [result, s.loc.snippet])
 
 proc assignLocalVar(p: BProc, n: PNode) =
   #assert(s.loc.k == locNone) # not yet assigned
@@ -773,7 +744,7 @@ proc getLabel(p: BProc): TLabel =
   result = "LA" & rope(p.labels) & "_"
 
 proc fixLabel(p: BProc, labl: TLabel) =
-  p.s(cpsStmts).addLabel(labl)
+  p.s(cpsStmts).add("$1: ;$n" % [labl])
 
 proc genVarPrototype(m: BModule, n: PNode)
 proc requestConstImpl(p: BProc, sym: PSym)
@@ -781,7 +752,8 @@ proc genStmts(p: BProc, t: PNode)
 proc expr(p: BProc, n: PNode, d: var TLoc)
 
 proc putLocIntoDest(p: BProc, d: var TLoc, s: TLoc)
-proc genLiteral(p: BProc, n: PNode; result: var Builder)
+proc intLiteral(i: BiggestInt; result: var Rope)
+proc genLiteral(p: BProc, n: PNode; result: var Rope)
 proc genOtherArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Rope; argsCounter: var int)
 proc raiseExit(p: BProc)
 proc raiseExitCleanup(p: BProc, destroy: string)
@@ -818,7 +790,7 @@ $1define nimlf_(n, file) \
   FR_.line = n; FR_.filename = file;
 
 """
-  if p.module.s[cfsFrameDefines].buf.len == 0:
+  if p.module.s[cfsFrameDefines].len == 0:
     appcg(p.module, p.module.s[cfsFrameDefines], frameDefines, ["#"])
 
   cgsym(p.module, "nimFrame")
@@ -859,7 +831,7 @@ proc loadDynamicLib(m: BModule, lib: PLib) =
       var s: TStringSeq = @[]
       libCandidates(lib.path.strVal, s)
       rawMessage(m.config, hintDependency, lib.path.strVal)
-      var loadlib = newBuilder("")
+      var loadlib: Rope = ""
       for i in 0..high(s):
         inc(m.labels)
         if i > 0: loadlib.add("||")
@@ -870,7 +842,7 @@ proc loadDynamicLib(m: BModule, lib: PLib) =
         loadlib.addf "))$n", []
       appcg(m, m.s[cfsDynLibInit],
             "if (!($1)) #nimLoadLibraryError(",
-            [extract(loadlib)])
+            [loadlib])
       genStringLiteral(m, lib.path, m.s[cfsDynLibInit])
       m.s[cfsDynLibInit].addf ");$n", []
 
@@ -884,9 +856,9 @@ proc loadDynamicLib(m: BModule, lib: PLib) =
            [getTypeDesc(m, lib.path.typ, dkVar), rdLoc(dest)])
       expr(p, lib.path, dest)
 
-      m.s[cfsVars].add(extract(p.s(cpsLocals)))
-      m.s[cfsDynLibInit].add(extract(p.s(cpsInit)))
-      m.s[cfsDynLibInit].add(extract(p.s(cpsStmts)))
+      m.s[cfsVars].add(p.s(cpsLocals))
+      m.s[cfsDynLibInit].add(p.s(cpsInit))
+      m.s[cfsDynLibInit].add(p.s(cpsStmts))
       appcg(m, m.s[cfsDynLibInit],
            "if (!($1 = #nimLoadLibrary($2))) #nimLoadLibraryError($2);$n",
            [tmp, rdLoc(dest)])
@@ -1006,12 +978,12 @@ proc generateHeaders(m: BModule) =
 #undef unix
 """)
 
-proc openNamespaceNim(namespace: string; result: var Builder) =
+proc openNamespaceNim(namespace: string; result: var Rope) =
   result.add("namespace ")
   result.add(namespace)
   result.add(" {\L")
 
-proc closeNamespaceNim(result: var Builder) =
+proc closeNamespaceNim(result: var Rope) =
   result.add("}\L")
 
 proc closureSetup(p: BProc, prc: PSym) =
@@ -1195,32 +1167,30 @@ proc allPathsAsgnResult(p: BProc; n: PNode): InitResultEnum =
 proc getProcTypeCast(m: BModule, prc: PSym): Rope =
   result = getTypeDesc(m, prc.loc.t)
   if prc.typ.callConv == ccClosure:
-    var rettype: Snippet = ""
-    var desc = newBuilder("")
+    var rettype, params: Rope = ""
     var check = initIntSet()
-    genProcParams(m, prc.typ, rettype, desc, check)
-    let params = extract(desc)
-    result = procPtrTypeUnnamed(rettype = rettype, params = params)
+    genProcParams(m, prc.typ, rettype, params, check)
+    result = "$1(*)$2" % [rettype, params]
 
 proc genProcBody(p: BProc; procBody: PNode) =
   genStmts(p, procBody) # modifies p.locals, p.init, etc.
   if {nimErrorFlagAccessed, nimErrorFlagDeclared, nimErrorFlagDisabled} * p.flags == {nimErrorFlagAccessed}:
     p.flags.incl nimErrorFlagDeclared
-    p.blocks[0].sections[cpsLocals].addVar(kind = Local,
-      name = "nimErr_", typ = ptrType("NIM_BOOL"))
-    p.blocks[0].sections[cpsInit].addAssignmentWithValue("nimErr_"):
-      p.blocks[0].sections[cpsInit].addCall(cgsymValue(p.module, "nimErrorFlag"))
+    p.blocks[0].sections[cpsLocals].add(ropecg(p.module, "NIM_BOOL* nimErr_;$n", []))
+    p.blocks[0].sections[cpsInit].add(ropecg(p.module, "nimErr_ = #nimErrorFlag();$n", []))
+
+proc isNoReturn(m: BModule; s: PSym): bool {.inline.} =
+  sfNoReturn in s.flags and m.config.exc != excGoto
 
 proc genProcAux*(m: BModule, prc: PSym) =
   var p = newProc(prc, m)
-  var header = newBuilder("")
+  var header = newRopeAppender()
   let isCppMember = m.config.backend == backendCpp and sfCppMember * prc.flags != {}
-  var visibility: DeclVisibility = None
   if isCppMember:
     genMemberProcHeader(m, prc, header)
   else:
-    genProcHeader(m, prc, header, visibility, asPtr = false, addAttributes = false)
-  var returnStmt: Snippet = ""
+    genProcHeader(m, prc, header)
+  var returnStmt: Rope = ""
   assert(prc.ast != nil)
 
   var procBody = transformBody(m.g.graph, m.idgen, prc, {})
@@ -1240,8 +1210,7 @@ proc genProcAux*(m: BModule, prc: PSym) =
       if sfNoInit in prc.flags and p.module.compileToCpp and (let val = easyResultAsgn(procBody); val != nil):
         var decl = localVarDecl(p, resNode)
         var a: TLoc = initLocExprSingleUse(p, val)
-        let ra = rdLoc(a)
-        p.s(cpsStmts).addAssignment(decl, ra)
+        linefmt(p, cpsStmts, "$1 = $2;$n", [decl, rdLoc(a)])
       else:
         # declare the result symbol:
         assignLocalVar(p, resNode)
@@ -1253,10 +1222,7 @@ proc genProcAux*(m: BModule, prc: PSym) =
           discard "result init optimized out"
         else:
           initLocalVar(p, res, immediateAsgn=false)
-      var returnBuilder = newBuilder("\t")
-      let rres = rdLoc(res.loc)
-      returnBuilder.addReturn(rres)
-      returnStmt = extract(returnBuilder)
+      returnStmt = ropecg(p.module, "\treturn $1;$n", [rdLoc(res.loc)])
     elif sfConstructor in prc.flags:
       resNode.sym.loc.flags.incl lfIndirect
       fillLoc(resNode.sym.loc, locParam, resNode, "this", OnHeap)
@@ -1287,56 +1253,45 @@ proc genProcAux*(m: BModule, prc: PSym) =
 
   prc.info = tmpInfo
 
-  var generatedProc = newBuilder("")
+  var generatedProc: Rope = ""
   generatedProc.genCLineDir prc.info, m.config
-  generatedProc.addDeclWithVisibility(visibility):
-    if sfPure in prc.flags:
-      generatedProc.add(extract(header))
-      generatedProc.finishProcHeaderWithBody():
-        generatedProc.add(extract(p.s(cpsLocals)))
-        generatedProc.add(extract(p.s(cpsInit)))
-        generatedProc.add(extract(p.s(cpsStmts)))
+  if isNoReturn(p.module, prc):
+    if hasDeclspec in extccomp.CC[p.config.cCompiler].props and not isCppMember:
+      header = "__declspec(noreturn) " & header
+  if sfPure in prc.flags:
+    if hasDeclspec in extccomp.CC[p.config.cCompiler].props and not isCppMember:
+      header = "__declspec(naked) " & header
+    generatedProc.add ropecg(p.module, "$1 {$n$2$3$4}$N$N",
+                         [header, p.s(cpsLocals), p.s(cpsInit), p.s(cpsStmts)])
+  else:
+    if m.hcrOn and isReloadable(m, prc):
+      # Add forward declaration for "_actual"-suffixed functions defined in the same module (or inline).
+      # This fixes the use of methods and also the case when 2 functions within the same module
+      # call each other using directly the "_actual" versions (an optimization) - see issue #11608
+      m.s[cfsProcHeaders].addf("$1;\n", [header])
+    generatedProc.add ropecg(p.module, "$1 {$n", [header])
+    if optStackTrace in prc.options:
+      generatedProc.add(p.s(cpsLocals))
+      var procname = makeCString(prc.name.s)
+      generatedProc.add(initFrame(p, procname, quotedFilename(p.config, prc.info)))
     else:
-      if m.hcrOn and isReloadable(m, prc):
-        m.s[cfsProcHeaders].addDeclWithVisibility(visibility):
-          # Add forward declaration for "_actual"-suffixed functions defined in the same module (or inline).
-          # This fixes the use of methods and also the case when 2 functions within the same module
-          # call each other using directly the "_actual" versions (an optimization) - see issue #11608
-          m.s[cfsProcHeaders].add(extract(header))
-          m.s[cfsProcHeaders].finishProcHeaderAsProto()
-      generatedProc.add(extract(header))
-      generatedProc.finishProcHeaderWithBody():
-        if optStackTrace in prc.options:
-          generatedProc.add(extract(p.s(cpsLocals)))
-          var procname = makeCString(prc.name.s)
-          generatedProc.add(initFrame(p, procname, quotedFilename(p.config, prc.info)))
-        else:
-          generatedProc.add(extract(p.s(cpsLocals)))
-        if optProfiler in prc.options:
-          # invoke at proc entry for recursion:
-          p.s(cpsInit).add('\t')
-          p.s(cpsInit).addCallStmt(cgsymValue(m, "nimProfile"))
-        if beforeRetNeeded in p.flags:
-          # this pair of {} is required for C++ (C++ is weird with its
-          # control flow integrity checks):
-          generatedProc.addScope():
-            generatedProc.add(extract(p.s(cpsInit)))
-            generatedProc.add(extract(p.s(cpsStmts)))
-          generatedProc.addLabel("BeforeRet_")
-        else:
-          generatedProc.add(extract(p.s(cpsInit)))
-          generatedProc.add(extract(p.s(cpsStmts)))
-        if optStackTrace in prc.options: generatedProc.add(deinitFrame(p))
-        generatedProc.add(returnStmt)
-  m.s[cfsProcs].add(extract(generatedProc))
+      generatedProc.add(p.s(cpsLocals))
+    if optProfiler in prc.options:
+      # invoke at proc entry for recursion:
+      appcg(p, cpsInit, "\t#nimProfile();$n", [])
+    # this pair of {} is required for C++ (C++ is weird with its
+    # control flow integrity checks):
+    if beforeRetNeeded in p.flags: generatedProc.add("{")
+    generatedProc.add(p.s(cpsInit))
+    generatedProc.add(p.s(cpsStmts))
+    if beforeRetNeeded in p.flags: generatedProc.add("\t}BeforeRet_: ;\n")
+    if optStackTrace in prc.options: generatedProc.add(deinitFrame(p))
+    generatedProc.add(returnStmt)
+    generatedProc.add("}\n")
+  m.s[cfsProcs].add(generatedProc)
   if isReloadable(m, prc):
-    m.s[cfsDynLibInit].add('\t')
-    m.s[cfsDynLibInit].addAssignmentWithValue(prc.loc.snippet):
-      m.s[cfsDynLibInit].addCast(getProcTypeCast(m, prc)):
-        m.s[cfsDynLibInit].addCall("hcrRegisterProc",
-          getModuleDllPath(m, prc),
-          '"' & prc.loc.snippet & '"',
-          cCast("void*", prc.loc.snippet & "_actual"))
+    m.s[cfsDynLibInit].addf("\t$1 = ($3) hcrRegisterProc($4, \"$1\", (void*)$2);$n",
+         [prc.loc.snippet, prc.loc.snippet & "_actual", getProcTypeCast(m, prc), getModuleDllPath(m, prc)])
 
 proc requiresExternC(m: BModule; sym: PSym): bool {.inline.} =
   result = (sfCompileToCpp in m.module.flags and
@@ -1353,39 +1308,26 @@ proc genProcPrototype(m: BModule, sym: PSym) =
   if lfDynamicLib in sym.loc.flags:
     if sym.itemId.module != m.module.position and
         not containsOrIncl(m.declaredThings, sym.id):
-      let vis = if isReloadable(m, sym): StaticProc else: Extern
-      let name = mangleDynLibProc(sym)
-      let t = getTypeDesc(m, sym.loc.t)
-      m.s[cfsVars].addDeclWithVisibility(vis):
-        m.s[cfsVars].addVar(kind = Local,
-          name = name,
-          typ = t)
+      m.s[cfsVars].add(ropecg(m, "$1 $2 $3;$n",
+                        [(if isReloadable(m, sym): "static" else: "extern"),
+                        getTypeDesc(m, sym.loc.t), mangleDynLibProc(sym)]))
       if isReloadable(m, sym):
-        m.s[cfsDynLibInit].add('\t')
-        m.s[cfsDynLibInit].addAssignmentWithValue(name):
-          m.s[cfsDynLibInit].addCast(t):
-            m.s[cfsDynLibInit].addCall("hcrGetProc",
-              getModuleDllPath(m, sym),
-              '"' & name & '"')
+        m.s[cfsDynLibInit].addf("\t$1 = ($2) hcrGetProc($3, \"$1\");$n",
+             [mangleDynLibProc(sym), getTypeDesc(m, sym.loc.t), getModuleDllPath(m, sym)])
   elif not containsOrIncl(m.declaredProtos, sym.id):
     let asPtr = isReloadable(m, sym)
-    var header = newBuilder("")
-    var visibility: DeclVisibility = None
-    genProcHeader(m, sym, header, visibility, asPtr = asPtr, addAttributes = true)
-    if asPtr:
-      m.s[cfsProcHeaders].addDeclWithVisibility(visibility):
-        # genProcHeader would give variable declaration, add it directly
-        m.s[cfsProcHeaders].add(extract(header))
-    else:
-      let extraVis =
-        if sym.typ.callConv != ccInline and requiresExternC(m, sym):
-          ExternC
-        else:
-          None
-      m.s[cfsProcHeaders].addDeclWithVisibility(extraVis):
-        m.s[cfsProcHeaders].addDeclWithVisibility(visibility):
-          m.s[cfsProcHeaders].add(extract(header))
-          m.s[cfsProcHeaders].finishProcHeaderAsProto()
+    var header = newRopeAppender()
+    genProcHeader(m, sym, header, asPtr)
+    if not asPtr:
+      if isNoReturn(m, sym) and hasDeclspec in extccomp.CC[m.config.cCompiler].props:
+        header = "__declspec(noreturn) " & header
+      if sym.typ.callConv != ccInline and requiresExternC(m, sym):
+        header = "extern \"C\" " & header
+      if sfPure in sym.flags and hasAttribute in CC[m.config.cCompiler].props:
+        header.add(" __attribute__((naked))")
+      if isNoReturn(m, sym) and hasAttribute in CC[m.config.cCompiler].props:
+        header.add(" __attribute__((noreturn))")
+    m.s[cfsProcHeaders].add(ropecg(m, "$1;$N", [header]))
 
 # TODO: figure out how to rename this - it DOES generate a forward declaration
 proc genProcNoForward(m: BModule, prc: PSym) =
@@ -1511,7 +1453,7 @@ proc genVarPrototype(m: BModule, n: PNode) =
         "\t$1 = ($2*)hcrGetGlobal($3, \"$1\");$n", [sym.loc.snippet,
         getTypeDesc(m, sym.loc.t, dkVar), getModuleDllPath(m, sym)])
 
-proc addNimDefines(result: var Builder; conf: ConfigRef) {.inline.} =
+proc addNimDefines(result: var Rope; conf: ConfigRef) {.inline.} =
   result.addf("#define NIM_INTBITS $1\L", [
     platform.CPU[conf.target.targetCPU].intSize.rope])
   if conf.cppCustomNamespace.len > 0:
@@ -1535,10 +1477,9 @@ proc getCopyright(conf: ConfigRef; cfile: Cfile): Rope =
         rope(getCompileCFileCmd(conf, cfile))]
 
 proc getFileHeader(conf: ConfigRef; cfile: Cfile): Rope =
-  var res = newBuilder(getCopyright(conf, cfile))
-  if conf.hcrOn: res.add("#define NIM_HOT_CODE_RELOADING\L")
-  addNimDefines(res, conf)
-  result = extract(res)
+  result = getCopyright(conf, cfile)
+  if conf.hcrOn: result.add("#define NIM_HOT_CODE_RELOADING\L")
+  addNimDefines(result, conf)
 
 proc getSomeNameForModule(conf: ConfigRef, filename: AbsoluteFile): Rope =
   ## Returns a mangled module name.
@@ -1581,9 +1522,8 @@ proc genMainProc(m: BModule) =
       assert prc != nil
       let n = newStrNode(nkStrLit, prc.annex.path.strVal)
       n.info = prc.annex.path.info
-      var strLitBuilder = newBuilder("")
-      genStringLiteral(m, n, strLitBuilder)
-      let strLit = extract(strLitBuilder)
+      var strLit = newRopeAppender()
+      genStringLiteral(m, n, strLit)
       appcg(m, result, "\tif (!($1 = #nimLoadLibrary($2)))$N" &
                        "\t\t#nimLoadLibraryError($2);$N",
                        [handle, strLit])
@@ -1795,10 +1735,10 @@ proc registerInitProcs*(g: BModuleList; m: PSym; flags: set[ModuleBackendFlag])
 proc whichInitProcs*(m: BModule): set[ModuleBackendFlag] =
   # called from IC.
   result = {}
-  if m.hcrOn or m.preInitProc.s(cpsInit).buf.len > 0 or m.preInitProc.s(cpsStmts).buf.len > 0:
+  if m.hcrOn or m.preInitProc.s(cpsInit).len > 0 or m.preInitProc.s(cpsStmts).len > 0:
     result.incl HasModuleInitProc
   for i in cfsTypeInit1..cfsDynLibInit:
-    if m.s[i].buf.len != 0:
+    if m.s[i].len != 0:
       result.incl HasDatInitProc
       break
 
@@ -1851,7 +1791,7 @@ proc registerModuleToMain(g: BModuleList; m: BModule) =
       m.s[cfsInitProc].add(hcrModuleMeta)
     return
 
-  if m.s[cfsDatInitProc].buf.len > 0:
+  if m.s[cfsDatInitProc].len > 0:
     g.mainModProcs.addf("N_LIB_PRIVATE N_NIMCALL(void, $1)(void);$N", [datInit])
     g.mainDatInit.addf("\t$1();$N", [datInit])
 
@@ -1863,7 +1803,7 @@ proc registerModuleToMain(g: BModuleList; m: BModule) =
     if m.config.target.targetOS != osStandalone and m.config.selectedGC notin {gcNone, gcArc, gcAtomicArc, gcOrc}:
       g.mainDatInit.add(ropecg(m, "\t#initStackBottomWith((void *)&inner);$N", []))
 
-  if m.s[cfsInitProc].buf.len > 0:
+  if m.s[cfsInitProc].len > 0:
     g.mainModProcs.addf("N_LIB_PRIVATE N_NIMCALL(void, $1)(void);$N", [init])
     let initCall = "\t$1();$N" % [init]
     if sfMainModule in m.module.flags:
@@ -1880,22 +1820,22 @@ proc genDatInitCode(m: BModule) =
 
   var moduleDatInitRequired = m.hcrOn
 
-  var prc = newBuilder("$1 N_NIMCALL(void, $2)(void) {$N" %
-    [rope(if m.hcrOn: "N_LIB_EXPORT" else: "N_LIB_PRIVATE"), getDatInitName(m)])
+  var prc = "$1 N_NIMCALL(void, $2)(void) {$N" %
+    [rope(if m.hcrOn: "N_LIB_EXPORT" else: "N_LIB_PRIVATE"), getDatInitName(m)]
 
   # we don't want to break into such init code - could happen if a line
   # directive from a function written by the user spills after itself
   genCLineDir(prc, InvalidFileIdx, 999999, m.config)
 
   for i in cfsTypeInit1..cfsDynLibInit:
-    if m.s[i].buf.len != 0:
+    if m.s[i].len != 0:
       moduleDatInitRequired = true
-      prc.add(extract(m.s[i]))
+      prc.add(m.s[i])
 
   prc.addf("}$N$N", [])
 
   if moduleDatInitRequired:
-    m.s[cfsDatInitProc].add(extract(prc))
+    m.s[cfsDatInitProc].add(prc)
     #rememberFlag(m.g.graph, m.module, HasDatInitProc)
 
 # Very similar to the contents of symInDynamicLib - basically only the
@@ -1922,8 +1862,8 @@ proc genInitCode(m: BModule) =
   ## into other modules, only simple rope manipulations are allowed
   var moduleInitRequired = m.hcrOn
   let initname = getInitName(m)
-  var prc = newBuilder("$1 N_NIMCALL(void, $2)(void) {$N" %
-    [rope(if m.hcrOn: "N_LIB_EXPORT" else: "N_LIB_PRIVATE"), initname])
+  var prc = "$1 N_NIMCALL(void, $2)(void) {$N" %
+    [rope(if m.hcrOn: "N_LIB_EXPORT" else: "N_LIB_PRIVATE"), initname]
   # we don't want to break into such init code - could happen if a line
   # directive from a function written by the user spills after itself
   genCLineDir(prc, InvalidFileIdx, 999999, m.config)
@@ -1946,13 +1886,13 @@ proc genInitCode(m: BModule) =
       [getModuleDllPath(m, m.module)])
 
   template writeSection(thing: untyped, section: TCProcSection, addHcrGuards = false) =
-    if m.thing.s(section).buf.len > 0:
+    if m.thing.s(section).len > 0:
       moduleInitRequired = true
       if addHcrGuards: prc.add("\tif (nim_hcr_do_init_) {\n\n")
-      prc.add(extract(m.thing.s(section)))
+      prc.add(m.thing.s(section))
       if addHcrGuards: prc.add("\n\t} // nim_hcr_do_init_\n")
 
-  if m.preInitProc.s(cpsInit).buf.len > 0 or m.preInitProc.s(cpsStmts).buf.len > 0:
+  if m.preInitProc.s(cpsInit).len > 0 or m.preInitProc.s(cpsStmts).len > 0:
     # Give this small function its own scope
     prc.addf("{$N", [])
     # Keep a bogus frame in case the code needs one
@@ -1972,7 +1912,7 @@ proc genInitCode(m: BModule) =
   prc.addf("{$N", [])
   writeSection(initProc, cpsLocals)
 
-  if m.initProc.s(cpsInit).buf.len > 0 or m.initProc.s(cpsStmts).buf.len > 0:
+  if m.initProc.s(cpsInit).len > 0 or m.initProc.s(cpsStmts).len > 0:
     moduleInitRequired = true
     if optStackTrace in m.initProc.options and frameDeclared notin m.flags:
       # BUT: the generated init code might depend on a current frame, so
@@ -2026,14 +1966,14 @@ proc genInitCode(m: BModule) =
       prc.add(ex)
 
   if moduleInitRequired or sfMainModule in m.module.flags:
-    m.s[cfsInitProc].add(extract(prc))
+    m.s[cfsInitProc].add(prc)
     #rememberFlag(m.g.graph, m.module, HasModuleInitProc)
 
   genDatInitCode(m)
 
   if m.hcrOn:
     m.s[cfsInitProc].addf("N_LIB_EXPORT N_NIMCALL(void, HcrCreateTypeInfos)(void) {$N", [])
-    m.s[cfsInitProc].add(extract(m.hcrCreateTypeInfosProc))
+    m.s[cfsInitProc].add(m.hcrCreateTypeInfosProc)
     m.s[cfsInitProc].addf("}$N$N", [])
 
   registerModuleToMain(m.g, m)
@@ -2075,32 +2015,31 @@ proc postprocessCode(conf: ConfigRef, r: var Rope) =
 proc genModule(m: BModule, cfile: Cfile): Rope =
   var moduleIsEmpty = true
 
-  var res = newBuilder(getFileHeader(m.config, cfile))
+  result = getFileHeader(m.config, cfile)
 
   generateThreadLocalStorage(m)
   generateHeaders(m)
-  res.add(extract(m.s[cfsHeaders]))
+  result.add(m.s[cfsHeaders])
   if m.config.cppCustomNamespace.len > 0:
-    openNamespaceNim(m.config.cppCustomNamespace, res)
-  if m.s[cfsFrameDefines].buf.len > 0:
-    res.add(extract(m.s[cfsFrameDefines]))
+    openNamespaceNim(m.config.cppCustomNamespace, result)
+  if m.s[cfsFrameDefines].len > 0:
+    result.add(m.s[cfsFrameDefines])
 
   for i in cfsForwardTypes..cfsProcs:
-    if m.s[i].buf.len > 0:
+    if m.s[i].len > 0:
       moduleIsEmpty = false
-      res.add(extract(m.s[i]))
+      result.add(m.s[i])
 
-  if m.s[cfsInitProc].buf.len > 0:
+  if m.s[cfsInitProc].len > 0:
     moduleIsEmpty = false
-    res.add(extract(m.s[cfsInitProc]))
-  if m.s[cfsDatInitProc].buf.len > 0 or m.hcrOn:
+    result.add(m.s[cfsInitProc])
+  if m.s[cfsDatInitProc].len > 0 or m.hcrOn:
     moduleIsEmpty = false
-    res.add(extract(m.s[cfsDatInitProc]))
+    result.add(m.s[cfsDatInitProc])
 
   if m.config.cppCustomNamespace.len > 0:
-    closeNamespaceNim(res)
+    closeNamespaceNim(result)
 
-  result = extract(res)
   if optLineDir in m.config.options:
     var srcFileDefs = ""
     for fi in 0..m.config.m.fileInfos.high:
@@ -2131,12 +2070,11 @@ proc rawNewModule(g: BModuleList; module: PSym, filename: AbsoluteFile): BModule
   result.typeInfoMarker = initTable[SigHash, Rope]()
   result.sigConflicts = initCountTable[SigHash]()
   result.initProc = newProc(nil, result)
-  for i in low(result.s)..high(result.s): result.s[i] = newBuilder("")
+  for i in low(result.s)..high(result.s): result.s[i] = newRopeAppender()
   result.initProc.options = initProcOptions(result)
   result.preInitProc = newProc(nil, result)
   result.preInitProc.flags.incl nimErrorFlagDisabled
   result.preInitProc.labels = 100_000 # little hack so that unique temporaries are generated
-  result.hcrCreateTypeInfosProc = newBuilder("")
   result.dataCache = initNodeTable()
   result.typeStack = @[]
   result.typeNodesName = getTempName(result)
@@ -2146,6 +2084,9 @@ proc rawNewModule(g: BModuleList; module: PSym, filename: AbsoluteFile): BModule
   if sfSystemModule in module.flags:
     incl result.flags, preventStackTrace
     excl(result.preInitProc.options, optStackTrace)
+  let ndiName = if optCDebug in g.config.globalOptions: changeFileExt(completeCfilePath(g.config, filename), "ndi")
+                else: AbsoluteFile""
+  open(result.ndi, ndiName, g.config)
 
 proc rawNewModule(g: BModuleList; module: PSym; conf: ConfigRef): BModule =
   result = rawNewModule(g, module, AbsoluteFile toFullPath(conf, module.position.FileIndex))
@@ -2175,7 +2116,7 @@ proc setupCgen*(graph: ModuleGraph; module: PSym; idgen: IdGenerator): PPassCont
     incl g.generatedHeader.flags, isHeaderFile
 
 proc writeHeader(m: BModule) =
-  var result = newBuilder(headerTop())
+  var result = headerTop()
   var guard = "__$1__" % [m.filename.splitFile.name.rope]
   result.addf("#ifndef $1$n#define $1$n", [guard])
   addNimDefines(result, m.config)
@@ -2183,17 +2124,17 @@ proc writeHeader(m: BModule) =
 
   generateThreadLocalStorage(m)
   for i in cfsHeaders..cfsProcs:
-    result.add(extract(m.s[i]))
+    result.add(m.s[i])
     if m.config.cppCustomNamespace.len > 0 and i == cfsHeaders:
       openNamespaceNim(m.config.cppCustomNamespace, result)
-  result.add(extract(m.s[cfsInitProc]))
+  result.add(m.s[cfsInitProc])
 
   if optGenDynLib in m.config.globalOptions:
     result.add("N_LIB_IMPORT ")
   result.addf("N_CDECL(void, $1NimMain)(void);$n", [rope m.config.nimMainPrefix])
   if m.config.cppCustomNamespace.len > 0: closeNamespaceNim(result)
   result.addf("#endif /* $1 */$n", [guard])
-  if not writeRope(extract(result), m.filename):
+  if not writeRope(result, m.filename):
     rawMessage(m.config, errCannotOpenFile, m.filename.string)
 
 proc getCFile(m: BModule): AbsoluteFile =
@@ -2275,6 +2216,7 @@ proc shouldRecompile(m: BModule; code: Rope, cfile: Cfile): bool =
 # it would generate multiple 'main' procs, for instance.
 
 proc writeModule(m: BModule, pending: bool) =
+  template onExit() = close(m.ndi, m.config)
   let cfile = getCFile(m)
   if moduleHasChanged(m.g.graph, m.module):
     genInitCode(m)
@@ -2292,10 +2234,12 @@ proc writeModule(m: BModule, pending: bool) =
     when hasTinyCBackend:
       if m.config.cmd == cmdTcc:
         tccgen.compileCCode($code, m.config)
+        onExit()
         return
 
     if not shouldRecompile(m, code, cf): cf.flags = {CfileFlag.Cached}
     addFileToCompile(m.config, cf)
+  onExit()
 
 proc updateCachedModule(m: BModule) =
   let cfile = getCFile(m)

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
@@ -161,7 +161,7 @@ type
     typeInfoMarkerV2*: TypeCache
     initProc*: BProc          # code for init procedure
     preInitProc*: BProc       # code executed before the init proc
-    hcrCreateTypeInfosProc*: Builder # type info globals are in here when HCR=on
+    hcrCreateTypeInfosProc*: Rope # type info globals are in here when HCR=on
     inHcrInitGuard*: bool     # We are currently within a HCR reloading guard.
     typeStack*: TTypeSeq      # used for type generation
     dataCache*: TNodeTable
@@ -172,6 +172,7 @@ type
                                              # OpenGL wrapper
     sigConflicts*: CountTable[SigHash]
     g*: BModuleList
+    ndi*: NdiFile
 
 template config*(m: BModule): ConfigRef = m.g.config
 template config*(p: BProc): ConfigRef = p.module.g.config
@@ -181,18 +182,18 @@ proc includeHeader*(this: BModule; header: string) =
   if not this.headerFiles.contains header:
     this.headerFiles.add header
 
-proc s*(p: BProc, s: TCProcSection): var Builder {.inline.} =
+proc s*(p: BProc, s: TCProcSection): var Rope {.inline.} =
   # section in the current block
   result = p.blocks[^1].sections[s]
 
-proc procSec*(p: BProc, s: TCProcSection): var Builder {.inline.} =
+proc procSec*(p: BProc, s: TCProcSection): var Rope {.inline.} =
   # top level proc sections
   result = p.blocks[0].sections[s]
 
 proc initBlock*(): TBlock =
   result = TBlock()
   for i in low(result.sections)..high(result.sections):
-    result.sections[i] = newBuilder("")
+    result.sections[i] = newRopeAppender()
 
 proc newProc*(prc: PSym, module: BModule): BProc =
   result = BProc(

compiler/cgmeth.nim

@@ -55,7 +55,7 @@ proc methodCall*(n: PNode; conf: ConfigRef): PNode =
   # replace ordinary method by dispatcher method:
   let disp = getDispatcher(result[0].sym)
   if disp != nil:
-    result[0].typ() = disp.typ
+    result[0].typ = disp.typ
     result[0].sym = disp
     # change the arguments to up/downcasts to fit the dispatcher's parameters:
     for i in 1..<result.len:

compiler/closureiters.nim

@@ -161,6 +161,10 @@ type
                     # is their finally. For finally it is parent finally. Otherwise -1
     idgen: IdGenerator
     varStates: Table[ItemId, int] # Used to detect if local variable belongs to multiple states
+    stateVarSym: PSym # :state variable. nil if env already introduced by lambdalifting
+      # remove if -d:nimOptIters is default, treating it as always nil
+    nimOptItersEnabled: bool # tracks if -d:nimOptIters is enabled
+      # should be default when issues are fixed, see #24094
 
 const
   nkSkip = {nkEmpty..nkNilLit, nkTemplateDef, nkTypeSection, nkStaticStmt,
@@ -170,8 +174,11 @@ const
   localRequiresLifting = -2
 
 proc newStateAccess(ctx: var Ctx): PNode =
-  result = rawIndirectAccess(newSymNode(getEnvParam(ctx.fn)),
+  if ctx.stateVarSym.isNil:
+    result = rawIndirectAccess(newSymNode(getEnvParam(ctx.fn)),
       getStateField(ctx.g, ctx.fn), ctx.fn.info)
+  else:
+    result = newSymNode(ctx.stateVarSym)
 
 proc newStateAssgn(ctx: var Ctx, toValue: PNode): PNode =
   # Creates state assignment:
@@ -189,12 +196,22 @@ proc newEnvVar(ctx: var Ctx, name: string, typ: PType): PSym =
   result.flags.incl sfNoInit
   assert(not typ.isNil, "Env var needs a type")
 
-  let envParam = getEnvParam(ctx.fn)
-  # let obj = envParam.typ.lastSon
-  result = addUniqueField(envParam.typ.elementType, result, ctx.g.cache, ctx.idgen)
+  if not ctx.stateVarSym.isNil:
+    # We haven't gone through labmda lifting yet, so just create a local var,
+    # it will be lifted later
+    if ctx.tempVars.isNil:
+      ctx.tempVars = newNodeI(nkVarSection, ctx.fn.info)
+      addVar(ctx.tempVars, newSymNode(result))
+  else:
+    let envParam = getEnvParam(ctx.fn)
+    # let obj = envParam.typ.lastSon
+    result = addUniqueField(envParam.typ.elementType, result, ctx.g.cache, ctx.idgen)
 
 proc newEnvVarAccess(ctx: Ctx, s: PSym): PNode =
-  result = rawIndirectAccess(newSymNode(getEnvParam(ctx.fn)), s, ctx.fn.info)
+  if ctx.stateVarSym.isNil:
+    result = rawIndirectAccess(newSymNode(getEnvParam(ctx.fn)), s, ctx.fn.info)
+  else:
+    result = newSymNode(s)
 
 proc newTempVarAccess(ctx: Ctx, s: PSym): PNode =
   result = newSymNode(s, ctx.fn.info)
@@ -246,12 +263,20 @@ proc newTempVarDef(ctx: Ctx, s: PSym, initialValue: PNode): PNode =
     v = ctx.g.emptyNode
   newTree(nkVarSection, newTree(nkIdentDefs, newSymNode(s), ctx.g.emptyNode, v))
 
+proc newEnvVarAsgn(ctx: Ctx, s: PSym, v: PNode): PNode
+
 proc newTempVar(ctx: var Ctx, typ: PType, parent: PNode, initialValue: PNode = nil): PSym =
-  result = newSym(skVar, getIdent(ctx.g.cache, ":tmpSlLower" & $ctx.tempVarId), ctx.idgen, ctx.fn, ctx.fn.info)
+  if ctx.nimOptItersEnabled:
+    result = newSym(skVar, getIdent(ctx.g.cache, ":tmpSlLower" & $ctx.tempVarId), ctx.idgen, ctx.fn, ctx.fn.info)
+  else:
+    result = ctx.newEnvVar(":tmpSlLower" & $ctx.tempVarId, typ)
   inc ctx.tempVarId
   result.typ = typ
   assert(not typ.isNil, "Temp var needs a type")
-  parent.add(ctx.newTempVarDef(result, initialValue))
+  if ctx.nimOptItersEnabled:
+    parent.add(ctx.newTempVarDef(result, initialValue))
+  elif initialValue != nil:
+    parent.add(ctx.newEnvVarAsgn(result, initialValue))
 
 proc hasYields(n: PNode): bool =
   # TODO: This is very inefficient. It traverses the node, looking for nkYieldStmt.
@@ -311,12 +336,12 @@ proc newNullifyCurExc(ctx: var Ctx, info: TLineInfo): PNode =
   let curExc = ctx.newCurExcAccess()
   curExc.info = info
   let nilnode = newNode(nkNilLit)
-  nilnode.typ() = curExc.typ
+  nilnode.typ = curExc.typ
   result = newTree(nkAsgn, curExc, nilnode)
 
 proc newOr(g: ModuleGraph, a, b: PNode): PNode {.inline.} =
   result = newTree(nkCall, newSymNode(g.getSysMagic(a.info, "or", mOr)), a, b)
-  result.typ() = g.getSysType(a.info, tyBool)
+  result.typ = g.getSysType(a.info, tyBool)
   result.info = a.info
 
 proc collectExceptState(ctx: var Ctx, n: PNode): PNode {.inline.} =
@@ -334,7 +359,7 @@ proc collectExceptState(ctx: var Ctx, n: PNode): PNode {.inline.} =
             newSymNode(g.getSysMagic(c.info, "of", mOf)),
             g.callCodegenProc("getCurrentException"),
             c[i])
-          nextCond.typ() = ctx.g.getSysType(c.info, tyBool)
+          nextCond.typ = ctx.g.getSysType(c.info, tyBool)
           nextCond.info = c.info
 
           if cond.isNil:
@@ -430,13 +455,24 @@ proc newTempVarAsgn(ctx: Ctx, s: PSym, v: PNode): PNode =
     result = newTree(nkFastAsgn, ctx.newTempVarAccess(s), v)
     result.info = v.info
 
+proc newEnvVarAsgn(ctx: Ctx, s: PSym, v: PNode): PNode =
+  # unused with -d:nimOptIters
+  if isEmptyType(v.typ):
+    result = v
+  else:
+    result = newTree(nkFastAsgn, ctx.newEnvVarAccess(s), v)
+    result.info = v.info
+
 proc addExprAssgn(ctx: Ctx, output, input: PNode, sym: PSym) =
+  var input = input
   if input.kind == nkStmtListExpr:
     let (st, res) = exprToStmtList(input)
     output.add(st)
-    output.add(ctx.newTempVarAsgn(sym, res))
-  else:
+    input = res
+  if ctx.nimOptItersEnabled:
     output.add(ctx.newTempVarAsgn(sym, input))
+  else:
+    output.add(ctx.newEnvVarAsgn(sym, input))
 
 proc convertExprBodyToAsgn(ctx: Ctx, exprBody: PNode, res: PSym): PNode =
   result = newNodeI(nkStmtList, exprBody.info)
@@ -444,11 +480,11 @@ proc convertExprBodyToAsgn(ctx: Ctx, exprBody: PNode, res: PSym): PNode =
 
 proc newNotCall(g: ModuleGraph; e: PNode): PNode =
   result = newTree(nkCall, newSymNode(g.getSysMagic(e.info, "not", mNot), e.info), e)
-  result.typ() = g.getSysType(e.info, tyBool)
+  result.typ = g.getSysType(e.info, tyBool)
 
 proc boolLit(g: ModuleGraph; info: TLineInfo; value: bool): PNode =
   result = newIntLit(g, info, ord value)
-  result.typ() = getSysType(g, info, tyBool)
+  result.typ = getSysType(g, info, tyBool)
 
 proc captureVar(c: var Ctx, s: PSym) =
   if c.varStates.getOrDefault(s.itemId) != localRequiresLifting:
@@ -486,7 +522,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
 
       result = newNodeI(nkStmtListExpr, n.info)
       if n.typ.isNil: internalError(ctx.g.config, "lowerStmtListExprs: constr typ.isNil")
-      result.typ() = n.typ
+      result.typ = n.typ
 
       for i in 0..<n.len:
         case n[i].kind
@@ -513,7 +549,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
       let isExpr = not isEmptyType(n.typ)
       if isExpr:
         result = newNodeI(nkStmtListExpr, n.info)
-        result.typ() = n.typ
+        result.typ = n.typ
         tmp = ctx.newTempVar(n.typ, result)
       else:
         result = newNodeI(nkStmtList, n.info)
@@ -565,7 +601,11 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
         else:
           internalError(ctx.g.config, "lowerStmtListExpr(nkIf): " & $branch.kind)
 
-      if isExpr: result.add(ctx.newTempVarAccess(tmp))
+      if isExpr:
+        if ctx.nimOptItersEnabled:
+          result.add(ctx.newTempVarAccess(tmp))
+        else:
+          result.add(ctx.newEnvVarAccess(tmp))
 
   of nkTryStmt, nkHiddenTryStmt:
     var ns = false
@@ -578,7 +618,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
 
       if isExpr:
         result = newNodeI(nkStmtListExpr, n.info)
-        result.typ() = n.typ
+        result.typ = n.typ
         let tmp = ctx.newTempVar(n.typ, result)
 
         n[0] = ctx.convertExprBodyToAsgn(n[0], tmp)
@@ -595,7 +635,10 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
           else:
             internalError(ctx.g.config, "lowerStmtListExpr(nkTryStmt): " & $branch.kind)
         result.add(n)
-        result.add(ctx.newTempVarAccess(tmp))
+        if ctx.nimOptItersEnabled:
+          result.add(ctx.newTempVarAccess(tmp))
+        else:
+          result.add(ctx.newEnvVarAccess(tmp))
 
   of nkCaseStmt:
     var ns = false
@@ -609,7 +652,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
 
       if isExpr:
         result = newNodeI(nkStmtListExpr, n.info)
-        result.typ() = n.typ
+        result.typ = n.typ
         let tmp = ctx.newTempVar(n.typ, result)
 
         if n[0].kind == nkStmtListExpr:
@@ -627,7 +670,10 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
           else:
             internalError(ctx.g.config, "lowerStmtListExpr(nkCaseStmt): " & $branch.kind)
         result.add(n)
-        result.add(ctx.newTempVarAccess(tmp))
+        if ctx.nimOptItersEnabled:
+          result.add(ctx.newTempVarAccess(tmp))
+        else:
+          result.add(ctx.newEnvVarAccess(tmp))
       elif n[0].kind == nkStmtListExpr:
         result = newNodeI(nkStmtList, n.info)
         let (st, ex) = exprToStmtList(n[0])
@@ -646,7 +692,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
 
       if isExpr:
         result = newNodeI(nkStmtListExpr, n.info)
-        result.typ() = n.typ
+        result.typ = n.typ
       else:
         result = newNodeI(nkStmtList, n.info)
 
@@ -660,7 +706,11 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
         let tmp = ctx.newTempVar(cond.typ, result, cond)
         # result.add(ctx.newTempVarAsgn(tmp, cond))
 
-        var check = ctx.newTempVarAccess(tmp)
+        var check: PNode
+        if ctx.nimOptItersEnabled:
+          check = ctx.newTempVarAccess(tmp)
+        else:
+          check = ctx.newEnvVarAccess(tmp)
         if n[0].sym.magic == mOr:
           check = ctx.g.newNotCall(check)
 
@@ -670,12 +720,18 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
           let (st, ex) = exprToStmtList(cond)
           ifBody.add(st)
           cond = ex
-        ifBody.add(ctx.newTempVarAsgn(tmp, cond))
+        if ctx.nimOptItersEnabled:
+          ifBody.add(ctx.newTempVarAsgn(tmp, cond))
+        else:
+          ifBody.add(ctx.newEnvVarAsgn(tmp, cond))
 
         let ifBranch = newTree(nkElifBranch, check, ifBody)
         let ifNode = newTree(nkIfStmt, ifBranch)
         result.add(ifNode)
-        result.add(ctx.newTempVarAccess(tmp))
+        if ctx.nimOptItersEnabled:
+          result.add(ctx.newTempVarAccess(tmp))
+        else:
+          result.add(ctx.newEnvVarAccess(tmp))
       else:
         for i in 0..<n.len:
           if n[i].kind == nkStmtListExpr:
@@ -686,7 +742,10 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
           if n[i].kind in nkCallKinds: # XXX: This should better be some sort of side effect tracking
             let tmp = ctx.newTempVar(n[i].typ, result, n[i])
             # result.add(ctx.newTempVarAsgn(tmp, n[i]))
-            n[i] = ctx.newTempVarAccess(tmp)
+            if ctx.nimOptItersEnabled:
+              n[i] = ctx.newTempVarAccess(tmp)
+            else:
+              n[i] = ctx.newEnvVarAccess(tmp)
 
         result.add(n)
 
@@ -732,7 +791,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
     if ns:
       needsSplit = true
       result = newNodeI(nkStmtListExpr, n.info)
-      result.typ() = n.typ
+      result.typ = n.typ
       let (st, ex) = exprToStmtList(n[^1])
       result.add(st)
       n[^1] = ex
@@ -802,7 +861,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
     if ns:
       needsSplit = true
       result = newNodeI(nkStmtListExpr, n.info)
-      result.typ() = n.typ
+      result.typ = n.typ
       let (st, ex) = exprToStmtList(n[0])
       result.add(st)
       n[0] = ex
@@ -814,10 +873,10 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
     if ns:
       needsSplit = true
       result = newNodeI(nkStmtListExpr, n.info)
-      result.typ() = n.typ
+      result.typ = n.typ
       let (st, ex) = exprToStmtList(n[1])
       n.transitionSonsKind(nkBlockStmt)
-      n.typ() = nil
+      n.typ = nil
       n[1] = st
       result.add(n)
       result.add(ex)
@@ -838,9 +897,9 @@ proc newEndFinallyNode(ctx: var Ctx, info: TLineInfo): PNode =
   #         raise
   let curExc = ctx.newCurExcAccess()
   let nilnode = newNode(nkNilLit)
-  nilnode.typ() = curExc.typ
+  nilnode.typ = curExc.typ
   let cmp = newTree(nkCall, newSymNode(ctx.g.getSysMagic(info, "==", mEqRef), info), curExc, nilnode)
-  cmp.typ() = ctx.g.getSysType(info, tyBool)
+  cmp.typ = ctx.g.getSysType(info, tyBool)
 
   let retStmt =
     if ctx.nearestFinally == 0:
@@ -1185,11 +1244,11 @@ proc newArrayType(g: ModuleGraph; n: int, t: PType; idgen: IdGenerator; owner: P
 
 proc createExceptionTable(ctx: var Ctx): PNode {.inline.} =
   result = newNodeI(nkBracket, ctx.fn.info)
-  result.typ() = ctx.g.newArrayType(ctx.exceptionTable.len, ctx.g.getSysType(ctx.fn.info, tyInt16), ctx.idgen, ctx.fn)
+  result.typ = ctx.g.newArrayType(ctx.exceptionTable.len, ctx.g.getSysType(ctx.fn.info, tyInt16), ctx.idgen, ctx.fn)
 
   for i in ctx.exceptionTable:
     let elem = newIntNode(nkIntLit, i)
-    elem.typ() = ctx.g.getSysType(ctx.fn.info, tyInt16)
+    elem.typ = ctx.g.getSysType(ctx.fn.info, tyInt16)
     result.add(elem)
 
 proc newCatchBody(ctx: var Ctx, info: TLineInfo): PNode {.inline.} =
@@ -1212,7 +1271,7 @@ proc newCatchBody(ctx: var Ctx, info: TLineInfo): PNode {.inline.} =
     let getNextState = newTree(nkBracketExpr,
       ctx.createExceptionTable(),
       ctx.newStateAccess())
-    getNextState.typ() = intTyp
+    getNextState.typ = intTyp
 
     # :state = exceptionTable[:state]
     result.add(ctx.newStateAssgn(getNextState))
@@ -1223,7 +1282,7 @@ proc newCatchBody(ctx: var Ctx, info: TLineInfo): PNode {.inline.} =
       ctx.g.getSysMagic(info, "==", mEqI).newSymNode(),
       ctx.newStateAccess(),
       newIntTypeNode(0, intTyp))
-    cond.typ() = boolTyp
+    cond.typ = boolTyp
 
     let raiseStmt = newTree(nkRaiseStmt, ctx.g.emptyNode)
     let ifBranch = newTree(nkElifBranch, cond, raiseStmt)
@@ -1236,7 +1295,7 @@ proc newCatchBody(ctx: var Ctx, info: TLineInfo): PNode {.inline.} =
       ctx.g.getSysMagic(info, "<", mLtI).newSymNode,
       newIntTypeNode(0, intTyp),
       ctx.newStateAccess())
-    cond.typ() = boolTyp
+    cond.typ = boolTyp
 
     let asgn = newTree(nkAsgn, ctx.newUnrollFinallyAccess(info), cond)
     result.add(asgn)
@@ -1247,12 +1306,12 @@ proc newCatchBody(ctx: var Ctx, info: TLineInfo): PNode {.inline.} =
       ctx.g.getSysMagic(info, "<", mLtI).newSymNode,
       ctx.newStateAccess(),
       newIntTypeNode(0, intTyp))
-    cond.typ() = boolTyp
+    cond.typ = boolTyp
 
     let negateState = newTree(nkCall,
       ctx.g.getSysMagic(info, "-", mUnaryMinusI).newSymNode,
       ctx.newStateAccess())
-    negateState.typ() = intTyp
+    negateState.typ = intTyp
 
     let ifBranch = newTree(nkElifBranch, cond, ctx.newStateAssgn(negateState))
     let ifStmt = newTree(nkIfStmt, ifBranch)
@@ -1284,6 +1343,13 @@ proc wrapIntoStateLoop(ctx: var Ctx, n: PNode): PNode =
   result.info = n.info
 
   let localVars = newNodeI(nkStmtList, n.info)
+  if not ctx.stateVarSym.isNil:
+    let varSect = newNodeI(nkVarSection, n.info)
+    addVar(varSect, newSymNode(ctx.stateVarSym))
+    localVars.add(varSect)
+
+    if not ctx.tempVars.isNil:
+      localVars.add(ctx.tempVars)
 
   let blockStmt = newNodeI(nkBlockStmt, n.info)
   blockStmt.add(newSymNode(ctx.stateLoopLabel))
@@ -1486,11 +1552,21 @@ proc liftLocals(c: var Ctx, n: PNode): PNode =
       n[i] = liftLocals(c, n[i])
 
 proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n: PNode): PNode =
-  var ctx = Ctx(g: g, fn: fn, idgen: idgen)
+  var ctx = Ctx(g: g, fn: fn, idgen: idgen,
+    # should be default when issues are fixed, see #24094:
+    nimOptItersEnabled: isDefined(g.config, "nimOptIters"))
 
-  # The transformation should always happen after at least partial lambdalifting
-  # is performed, so that the closure iter environment is always created upfront.
-  doAssert(getEnvParam(fn) != nil, "Env param not created before iter transformation")
+  if getEnvParam(fn).isNil:
+    if ctx.nimOptItersEnabled:
+      # The transformation should always happen after at least partial lambdalifting
+      # is performed, so that the closure iter environment is always created upfront.
+      doAssert(false, "Env param not created before iter transformation")
+    else:
+      # Lambda lifting was not done yet. Use temporary :state sym, which will
+      # be handled specially by lambda lifting. Local temp vars (if needed)
+      # should follow the same logic.
+      ctx.stateVarSym = newSym(skVar, getIdent(ctx.g.cache, ":state"), idgen, fn, fn.info)
+      ctx.stateVarSym.typ = g.createClosureIterStateType(fn, idgen)
 
   ctx.stateLoopLabel = newSym(skLabel, getIdent(ctx.g.cache, ":stateLoop"), idgen, fn, fn.info)
   var pc = PreprocessContext(finallys: @[], config: g.config, idgen: idgen)
@@ -1516,9 +1592,10 @@ proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n:
   let caseDispatcher = newTreeI(nkCaseStmt, n.info,
       ctx.newStateAccess())
 
-  # Lamdalifting will not touch our locals, it is our responsibility to lift those that
-  # need it.
-  detectCapturedVars(ctx)
+  if ctx.nimOptItersEnabled:
+    # Lamdalifting will not touch our locals, it is our responsibility to lift those that
+    # need it.
+    detectCapturedVars(ctx)
 
   for s in ctx.states:
     let body = ctx.transformStateAssignments(s.body)
@@ -1527,7 +1604,8 @@ proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n:
   caseDispatcher.add newTreeI(nkElse, n.info, newTreeI(nkReturnStmt, n.info, g.emptyNode))
 
   result = wrapIntoStateLoop(ctx, caseDispatcher)
-  result = liftLocals(ctx, result)
+  if ctx.nimOptItersEnabled:
+    result = liftLocals(ctx, result)
 
   when false:
     echo "TRANSFORM TO STATES: "

compiler/concepts.nim

@@ -11,7 +11,7 @@
 ## for details. Note this is a first implementation and only the "Concept matching"
 ## section has been implemented.
 
-import ast, semdata, lookups, lineinfos, idents, msgs, renderer, types, layeredtable
+import ast, astalgo, semdata, lookups, lineinfos, idents, msgs, renderer, types
 
 import std/intsets
 
@@ -309,7 +309,7 @@ proc conceptMatchNode(c: PContext; n: PNode; m: var MatchCon): bool =
     # error was reported earlier.
     result = false
 
-proc conceptMatch*(c: PContext; concpt, arg: PType; bindings: var LayeredIdTable; invocation: PType): bool =
+proc conceptMatch*(c: PContext; concpt, arg: PType; bindings: var TypeMapping; 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
@@ -328,16 +328,16 @@ proc conceptMatch*(c: PContext; concpt, arg: PType; bindings: var LayeredIdTable
           dest = existingBinding(m, dest)
           if dest == nil or dest.kind != tyGenericParam: break
         if dest != nil:
-          bindings.put(a, dest)
+          bindings.idTablePut(a, dest)
           when logBindings: echo "A bind ", a, " ", dest
       else:
-        bindings.put(a, b)
+        bindings.idTablePut(a, b)
         when logBindings: echo "B bind ", a, " ", b
     # we have a match, so bind 'arg' itself to 'concpt':
-    bindings.put(concpt, arg)
+    bindings.idTablePut(concpt, arg)
     # invocation != nil means we have a non-atomic concept:
     if invocation != nil and arg.kind == tyGenericInst and invocation.kidsLen == arg.kidsLen-1:
       # bind even more generic parameters
       assert invocation.kind == tyGenericInvocation
       for i in FirstGenericParamAt ..< invocation.kidsLen:
-        bindings.put(invocation[i], arg[i])
+        bindings.idTablePut(invocation[i], arg[i])

compiler/condsyms.nim

@@ -169,5 +169,3 @@ proc initDefines*(symbols: StringTableRef) =
   defineSymbol("nimHasGenericsOpenSym2")
   defineSymbol("nimHasGenericsOpenSym3")
   defineSymbol("nimHasJsNoLambdaLifting")
-  defineSymbol("nimHasDefaultFloatRoundtrip")
-  defineSymbol("nimHasXorSet")

compiler/docgen.nim

@@ -115,7 +115,7 @@ proc add(dest: var ItemPre, str: string) = dest.add ItemFragment(isRst: false, s
 
 proc addRstFileIndex(d: PDoc, fileIndex: lineinfos.FileIndex): rstast.FileIndex =
   let invalid = rstast.FileIndex(-1)
-  result = d.nimToRstFid.getOrDefault(fileIndex, invalid)
+  result = d.nimToRstFid.getOrDefault(fileIndex, default = invalid)
   if result == invalid:
     let fname = toFullPath(d.conf, fileIndex)
     result = addFilename(d.sharedState, fname)
@@ -830,7 +830,7 @@ proc getName(n: PNode): string =
   of nkAccQuoted:
     result = "`"
     for i in 0..<n.len: result.add(getName(n[i]))
-    result.add('`')
+    result = "`"
   of nkOpenSymChoice, nkClosedSymChoice, nkOpenSym:
     result = getName(n[0])
   else:
@@ -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)

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

@@ -64,7 +64,7 @@ proc evalTemplateAux(templ, actual: PNode, c: var TemplCtx, result: PNode) =
         if x == nil:
           x = copySym(s, c.idgen)
           # sem'check needs to set the owner properly later, see bug #9476
-          setOwner(x, nil) # c.genSymOwner
+          x.owner = nil # c.genSymOwner
           #if x.kind == skParam and x.owner.kind == skModule:
           #  internalAssert c.config, false
           idTablePut(c.mapping, s, x)
@@ -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

@@ -63,7 +63,7 @@ type
 
 # Configuration settings for various compilers.
 # When adding new compilers, the cmake sources could be a good reference:
-# https://cmake.org/gitweb?p=cmake.git;a=tree;f=Modules/Platform;
+# http://cmake.org/gitweb?p=cmake.git;a=tree;f=Modules/Platform;
 
 template compiler(name, settings: untyped): untyped =
   proc name: TInfoCC {.compileTime.} = settings
@@ -162,11 +162,7 @@ compiler vcc:
     linkerExe: "cl",
     linkTmpl: "$builddll$vccplatform /Fe$exefile $objfiles $buildgui /nologo $options",
     includeCmd: " /I",
-    # HACK: we call `cl` so we have to pass `/link` for linker options,
-    # but users may still want to pass arguments to `cl` (see #14221)
-    # to deal with this, we add `/link` before each `/LIBPATH`,
-    # the linker ignores extra `/link`s since it's an unrecognized argument
-    linkDirCmd: " /link /LIBPATH:",
+    linkDirCmd: " /LIBPATH:",
     linkLibCmd: " $1.lib",
     debug: " /RTC1 /Z7 ",
     pic: "",
@@ -781,7 +777,7 @@ proc getLinkCmd(conf: ConfigRef; output: AbsoluteFile,
     # https://blog.molecular-matters.com/2017/05/09/deleting-pdb-files-locked-by-visual-studio/
     # and a bit about the .pdb format in case that is ever needed:
     # https://github.com/crosire/blink
-    # https://www.debuginfo.com/articles/debuginfomatch.html#pdbfiles
+    # http://www.debuginfo.com/articles/debuginfomatch.html#pdbfiles
     if conf.hcrOn and isVSCompatible(conf):
       let t = now()
       let pdb = output.string & "." & format(t, "MMMM-yyyy-HH-mm-") & $t.nanosecond & ".pdb"
@@ -1004,11 +1000,10 @@ proc jsonBuildInstructionsFile*(conf: ConfigRef): AbsoluteFile =
   # works out of the box with `hashMainCompilationParams`.
   result = getNimcacheDir(conf) / conf.outFile.changeFileExt("json")
 
-const cacheVersion = "D20240927T193831" # update when `BuildCache` spec changes
+const cacheVersion = "D20210525T193831" # update when `BuildCache` spec changes
 type BuildCache = object
   cacheVersion: string
   outputFile: string
-  outputLastModificationTime: string
   compile: seq[(string, string)]
   link: seq[string]
   linkcmd: string
@@ -1052,8 +1047,6 @@ proc writeJsonBuildInstructions*(conf: ConfigRef; deps: StringTableRef) =
           bcache.depfiles.add (path, $secureHashFile(path))
 
     bcache.nimexe = hashNimExe()
-    if fileExists(bcache.outputFile):
-      bcache.outputLastModificationTime = $getLastModificationTime(bcache.outputFile)
   conf.jsonBuildFile = conf.jsonBuildInstructionsFile
   conf.jsonBuildFile.string.writeFile(bcache.toJson.pretty)
 
@@ -1074,8 +1067,6 @@ proc changeDetectedViaJsonBuildInstructions*(conf: ConfigRef; jsonFile: Absolute
     # xxx optimize by returning false if stdin input was the same
   for (file, hash) in bcache.depfiles:
     if $secureHashFile(file) != hash: return true
-  if bcache.outputLastModificationTime != $getLastModificationTime(bcache.outputFile):
-    return true
 
 proc runJsonBuildInstructions*(conf: ConfigRef; jsonFile: AbsoluteFile) =
   var bcache: BuildCache = default(BuildCache)
@@ -1092,7 +1083,7 @@ proc runJsonBuildInstructions*(conf: ConfigRef; jsonFile: AbsoluteFile) =
       "jsonscript command outputFile '$1' must match '$2' which was specified during --compileOnly, see \"outputFile\" entry in '$3' " %
       [outputCurrent, output, jsonFile.string])
   var cmds: TStringSeq = default(TStringSeq)
-  var prettyCmds: TStringSeq = default(TStringSeq)
+  var prettyCmds: TStringSeq= default(TStringSeq)
   let prettyCb = proc (idx: int) = writePrettyCmdsStderr(prettyCmds[idx])
   for (name, cmd) in bcache.compile:
     cmds.add cmd

compiler/guards.nim

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

compiler/ic/ic.nim

@@ -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)
@@ -942,7 +942,7 @@ proc symBodyFromPacked(c: var PackedDecoder; g: var PackedModuleGraph;
     result.guard = loadSym(c, g, si, s.guard)
     result.bitsize = s.bitsize
     result.alignment = s.alignment
-  setOwner(result, loadSym(c, g, si, s.owner))
+  result.owner = loadSym(c, g, si, s.owner)
   let externalName = g[si].fromDisk.strings[s.externalName]
   if externalName != "":
     result.loc.snippet = externalName
@@ -998,7 +998,7 @@ proc typeHeaderFromPacked(c: var PackedDecoder; g: var PackedModuleGraph;
 proc typeBodyFromPacked(c: var PackedDecoder; g: var PackedModuleGraph;
                         t: PackedType; si, item: int32; result: PType) =
   result.sym = loadSym(c, g, si, t.sym)
-  setOwner(result, loadSym(c, g, si, t.owner))
+  result.owner = loadSym(c, g, si, t.owner)
   when false:
     for op, item in pairs t.attachedOps:
       result.attachedOps[op] = loadSym(c, g, si, item)
@@ -1062,7 +1062,7 @@ proc setupLookupTables(g: var PackedModuleGraph; conf: ConfigRef; cache: IdentCa
                   name: getIdent(cache, splitFile(filename).name),
                   info: newLineInfo(fileIdx, 1, 1),
                   position: int(fileIdx))
-  setOwner(m.module, getPackage(conf, cache, fileIdx))
+  m.module.owner = getPackage(conf, cache, fileIdx)
   m.module.flags = m.fromDisk.moduleFlags
 
 proc loadToReplayNodes(g: var PackedModuleGraph; conf: ConfigRef; cache: IdentCache;

compiler/injectdestructors.nim

@@ -317,9 +317,8 @@ proc isCriticalLink(dest: PNode): bool {.inline.} =
   ]#
   result = dest.kind != nkSym
 
-proc finishCopy(c: var Con; result, dest: PNode; flags: set[MoveOrCopyFlag]; isFromSink: bool) =
-  if c.graph.config.selectedGC == gcOrc and IsExplicitSink notin flags:
-    # add cyclic flag, but not to sink calls, which IsExplicitSink generates
+proc finishCopy(c: var Con; result, dest: PNode; isFromSink: bool) =
+  if c.graph.config.selectedGC == gcOrc:
     let t = dest.typ.skipTypes(tyUserTypeClasses + {tyGenericInst, tyAlias, tySink, tyDistinct})
     if cyclicType(c.graph, t):
       result.add boolLit(c.graph, result.info, isFromSink or isCriticalLink(dest))
@@ -332,7 +331,7 @@ proc genMarkCyclic(c: var Con; result, dest: PNode) =
         result.add callCodegenProc(c.graph, "nimMarkCyclic", dest.info, dest)
       else:
         let xenv = genBuiltin(c.graph, c.idgen, mAccessEnv, "accessEnv", dest)
-        xenv.typ() = getSysType(c.graph, dest.info, tyPointer)
+        xenv.typ = getSysType(c.graph, dest.info, tyPointer)
         result.add callCodegenProc(c.graph, "nimMarkCyclic", dest.info, xenv)
 
 proc genCopyNoCheck(c: var Con; dest, ri: PNode; a: TTypeAttachedOp): PNode =
@@ -408,7 +407,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)
@@ -465,7 +464,7 @@ proc passCopyToSink(n: PNode; c: var Con; s: var Scope): PNode =
       var newCall = newTreeIT(nkCall, src.info, src.typ,
             newSymNode(op),
             src)
-      c.finishCopy(newCall, n, {}, isFromSink = true)
+      c.finishCopy(newCall, n, isFromSink = true)
       result.add newTreeI(nkFastAsgn,
           src.info, tmp,
           newCall
@@ -474,7 +473,7 @@ proc passCopyToSink(n: PNode; c: var Con; s: var Scope): PNode =
       result.add c.genWasMoved(tmp)
       var m = c.genCopy(tmp, n, {})
       m.add p(n, c, s, normal)
-      c.finishCopy(m, n, {}, isFromSink = true)
+      c.finishCopy(m, n, isFromSink = true)
       result.add m
     if isLValue(n) and not isCapturedVar(n) and nTyp.skipTypes(abstractInst).kind != tyRef and c.inSpawn == 0:
       message(c.graph.config, n.info, hintPerformance,
@@ -762,7 +761,7 @@ proc pRaiseStmt(n: PNode, c: var Con; s: var Scope): PNode =
       let tmp = c.getTemp(s, n[0].typ, n.info)
       var m = c.genCopyNoCheck(tmp, n[0], attachedAsgn)
       m.add p(n[0], c, s, normal)
-      c.finishCopy(m, n[0], {}, isFromSink = false)
+      c.finishCopy(m, n[0], isFromSink = false)
       result = newTree(nkStmtList, c.genWasMoved(tmp), m)
       var toDisarm = n[0]
       if toDisarm.kind == nkStmtListExpr: toDisarm = toDisarm.lastSon
@@ -822,9 +821,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}:
@@ -1022,9 +1021,9 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
           n[1].typ.skipTypes(abstractInst-{tyOwned}).kind == tyOwned:
         # allow conversions from owned to unowned via this little hack:
         let nTyp = n[1].typ
-        n[1].typ() = n.typ
+        n[1].typ = n.typ
         result[1] = p(n[1], c, s, mode)
-        result[1].typ() = nTyp
+        result[1].typ = nTyp
       else:
         result[1] = p(n[1], c, s, mode)
 
@@ -1174,7 +1173,7 @@ proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopy
         result = c.genCopy(dest, ri, flags)
         dec c.inEnsureMove, isEnsureMove
         result.add p(ri, c, s, consumed)
-        c.finishCopy(result, dest, flags, isFromSink = false)
+        c.finishCopy(result, dest, isFromSink = false)
     of nkBracket:
       # array constructor
       if ri.len > 0 and isDangerousSeq(ri.typ):
@@ -1182,7 +1181,7 @@ proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopy
         result = c.genCopy(dest, ri, flags)
         dec c.inEnsureMove, isEnsureMove
         result.add p(ri, c, s, consumed)
-        c.finishCopy(result, dest, flags, isFromSink = false)
+        c.finishCopy(result, dest, isFromSink = false)
       else:
         result = c.genSink(s, dest, p(ri, c, s, consumed), flags)
     of nkObjConstr, nkTupleConstr, nkClosure, nkCharLit..nkNilLit:
@@ -1203,7 +1202,7 @@ proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopy
         result = c.genCopy(dest, ri, flags)
         dec c.inEnsureMove, isEnsureMove
         result.add p(ri, c, s, consumed)
-        c.finishCopy(result, dest, flags, isFromSink = false)
+        c.finishCopy(result, dest, isFromSink = false)
     of nkHiddenSubConv, nkHiddenStdConv, nkConv, nkObjDownConv, nkObjUpConv, nkCast:
       result = c.genSink(s, dest, p(ri, c, s, sinkArg), flags)
     of nkStmtListExpr, nkBlockExpr, nkIfExpr, nkCaseStmt, nkTryStmt:
@@ -1223,7 +1222,7 @@ proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopy
         result = c.genCopy(dest, ri, flags)
         dec c.inEnsureMove, isEnsureMove
         result.add p(ri, c, s, consumed)
-        c.finishCopy(result, dest, flags, isFromSink = false)
+        c.finishCopy(result, dest, isFromSink = false)
 
 when false:
   proc computeUninit(c: var Con) =

compiler/jsgen.nim

@@ -1585,8 +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:
+    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:
@@ -2451,7 +2458,6 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
   of mMulSet: binaryExpr(p, n, r, "SetMul", "SetMul($1, $2)")
   of mPlusSet: binaryExpr(p, n, r, "SetPlus", "SetPlus($1, $2)")
   of mMinusSet: binaryExpr(p, n, r, "SetMinus", "SetMinus($1, $2)")
-  of mXorSet: binaryExpr(p, n, r, "SetXor", "SetXor($1, $2)")
   of mIncl: binaryExpr(p, n, r, "", "$1[$2] = true")
   of mExcl: binaryExpr(p, n, r, "", "delete $1[$2]")
   of mInSet:

compiler/lambdalifting.nim

@@ -150,7 +150,7 @@ template isIterator*(owner: PSym): bool =
 
 proc createEnvObj(g: ModuleGraph; idgen: IdGenerator; owner: PSym; info: TLineInfo): PType =
   result = createObj(g, idgen, owner, info, final=false)
-  if owner.isIterator:
+  if owner.isIterator or not isDefined(g.config, "nimOptIters"):
     rawAddField(result, createStateField(g, owner, idgen))
 
 proc getClosureIterResult*(g: ModuleGraph; iter: PSym; idgen: IdGenerator): PSym =
@@ -175,7 +175,6 @@ proc addHiddenParam(routine: PSym, param: PSym) =
   #echo "produced environment: ", param.id, " for ", routine.id
 
 proc getEnvParam*(routine: PSym): PSym =
-  if routine.ast.isNil: return nil
   let params = routine.ast[paramsPos]
   let hidden = lastSon(params)
   if hidden.kind == nkSym and hidden.sym.kind == skParam and hidden.sym.name.s == paramName:
@@ -229,6 +228,13 @@ proc makeClosure*(g: ModuleGraph; idgen: IdGenerator; prc: PSym; env: PNode; inf
   if tfHasAsgn in result.typ.flags or optSeqDestructors in g.config.globalOptions:
     prc.flags.incl sfInjectDestructors
 
+proc interestingIterVar(s: PSym): bool {.inline.} =
+  # unused with -d:nimOptIters
+  # XXX optimization: Only lift the variable if it lives across
+  # yield/return boundaries! This can potentially speed up
+  # closure iterators quite a bit.
+  result = s.kind in {skResult, skVar, skLet, skTemp, skForVar} and sfGlobal notin s.flags
+
 template liftingHarmful(conf: ConfigRef; owner: PSym): bool =
   ## lambda lifting can be harmful for JS-like code generators.
   let isCompileTime = sfCompileTime in owner.flags or owner.kind == skMacro
@@ -275,6 +281,16 @@ proc liftIterSym*(g: ModuleGraph; n: PNode; idgen: IdGenerator; owner: PSym): PN
   createTypeBoundOpsLL(g, env.typ, n.info, idgen, owner)
   result.add makeClosure(g, idgen, iter, env, n.info)
 
+proc freshVarForClosureIter*(g: ModuleGraph; s: PSym; idgen: IdGenerator; owner: PSym): PNode =
+  # unused with -d:nimOptIters
+  let envParam = getHiddenParam(g, owner)
+  let obj = envParam.typ.skipTypes({tyOwned, tyRef, tyPtr})
+  let field = addField(obj, s, g.cache, idgen)
+
+  var access = newSymNode(envParam)
+  assert obj.kind == tyObject
+  result = rawIndirectAccess(access, field, s.info)
+
 # ------------------ new stuff -------------------------------------------
 
 proc markAsClosure(g: ModuleGraph; owner: PSym; n: PNode) =
@@ -284,8 +300,8 @@ proc markAsClosure(g: ModuleGraph; owner: PSym; n: PNode) =
     localError(g.config, n.info,
       ("'$1' is of type <$2> which cannot be captured as it would violate memory" &
        " safety, declared here: $3; using '-d:nimNoLentIterators' helps in some cases." &
-       " Consider using a <ref T> which can be captured.") %
-      [s.name.s, typeToString(s.typ.skipTypes({tyVar})), g.config$s.info])
+       " Consider using a <ref $2> which can be captured.") %
+      [s.name.s, typeToString(s.typ), g.config$s.info])
   elif not (owner.typ.isClosure or owner.isNimcall and not owner.isExplicitCallConv or isEnv):
     localError(g.config, n.info, "illegal capture '$1' because '$2' has the calling convention: <$3>" %
       [s.name.s, owner.name.s, $owner.typ.callConv])
@@ -323,7 +339,7 @@ proc getEnvTypeForOwner(c: var DetectionPass; owner: PSym;
   result = c.ownerToType.getOrDefault(owner.id)
   if result.isNil:
     let env = getEnvParam(owner)
-    if env.isNil or not owner.isIterator:
+    if env.isNil or not owner.isIterator or not isDefined(c.graph.config, "nimOptIters"):
       result = newType(tyRef, c.idgen, owner)
       let obj = createEnvObj(c.graph, c.idgen, owner, info)
       rawAddSon(result, obj)
@@ -420,12 +436,6 @@ proc addClosureParam(c: var DetectionPass; fn: PSym; info: TLineInfo) =
     localError(c.graph.config, fn.info, "internal error: inconsistent environment type")
   #echo "adding closure to ", fn.name.s
 
-proc iterEnvHasUpField(g: ModuleGraph, iter: PSym): bool =
-  let cp = getEnvParam(iter)
-  doAssert(cp != nil, "Env param not present in iter")
-  let upField = lookupInRecord(cp.typ.skipTypes({tyOwned, tyRef, tyPtr}).n, getIdent(g.cache, upName))
-  upField != nil
-
 proc detectCapturedVars(n: PNode; owner: PSym; c: var DetectionPass) =
   case n.kind
   of nkSym:
@@ -444,12 +454,23 @@ proc detectCapturedVars(n: PNode; owner: PSym; c: var DetectionPass) =
         let body = transformBody(c.graph, c.idgen, s, {useCache})
         detectCapturedVars(body, s, c)
     let ow = s.skipGenericOwner
-    let innerClosure = innerProc and s.typ.callConv == ccClosure and (not s.isIterator or iterEnvHasUpField(c.graph, s))
+    let innerClosure = innerProc and s.typ.callConv == ccClosure and not s.isIterator
     let interested = interestingVar(s)
     if ow == owner:
       if owner.isIterator:
         c.somethingToDo = true
         addClosureParam(c, owner, n.info)
+        if not isDefined(c.graph.config, "nimOptIters") and interestingIterVar(s):
+          if not c.capturedVars.contains(s.id):
+            if not c.inTypeOf: c.capturedVars.incl(s.id)
+            let obj = getHiddenParam(c.graph, owner).typ.skipTypes({tyOwned, tyRef, tyPtr})
+            #let obj = c.getEnvTypeForOwner(s.owner).skipTypes({tyOwned, tyRef, tyPtr})
+
+            if s.name.id == getIdent(c.graph.cache, ":state").id:
+              obj.n[0].sym.flags.incl sfNoInit
+              obj.n[0].sym.itemId = ItemId(module: s.itemId.module, item: -s.itemId.item)
+            else:
+              discard addField(obj, s, c.graph.cache, c.idgen)
     # direct or indirect dependency:
     elif innerClosure or interested:
       discard """
@@ -609,7 +630,7 @@ proc rawClosureCreation(owner: PSym;
       let unowned = c.unownedEnvVars[owner.id]
       assert unowned != nil
       let env2 = copyTree(env)
-      env2.typ() = unowned.typ
+      env2.typ = unowned.typ
       result.add newAsgnStmt(unowned, env2, env.info)
       createTypeBoundOpsLL(d.graph, unowned.typ, env.info, d.idgen, owner)
 
@@ -649,27 +670,16 @@ proc finishClosureCreation(owner: PSym; d: var DetectionPass; c: LiftingPass;
     res.add newAsgnStmt(unowned, nilLit, info)
     createTypeBoundOpsLL(d.graph, unowned.typ, info, d.idgen, owner)
 
-proc getUpForIter(g: ModuleGraph; owner, iterOwner: PSym, expectedUpTyp: PType): PNode =
-  var p = getHiddenParam(g, owner)
-  var res = p.newSymNode
-  while res.typ.skipTypes({tyOwned, tyRef, tyPtr}) != expectedUpTyp:
-    let upField = lookupInRecord(p.typ.skipTypes({tyOwned, tyRef, tyPtr}).n, getIdent(g.cache, upName))
-    if upField == nil:
-      return nil
-    p = upField
-    res = rawIndirectAccess(res, upField, p.info)
-  res
-
-proc closureCreationForIter(owner: PSym, iter: PNode;
+proc closureCreationForIter(iter: PNode;
                             d: var DetectionPass; c: var LiftingPass): PNode =
   result = newNodeIT(nkStmtListExpr, iter.info, iter.sym.typ)
-  let iterOwner = iter.sym.skipGenericOwner
-  var v = newSym(skVar, getIdent(d.graph.cache, envName), d.idgen, iterOwner, iter.info)
+  let owner = iter.sym.skipGenericOwner
+  var v = newSym(skVar, getIdent(d.graph.cache, envName), d.idgen, owner, iter.info)
   incl(v.flags, sfShadowed)
   v.typ = asOwnedRef(d, getHiddenParam(d.graph, iter.sym).typ)
   var vnode: PNode
-  if iterOwner.isIterator:
-    let it = getHiddenParam(d.graph, iterOwner)
+  if owner.isIterator:
+    let it = getHiddenParam(d.graph, owner)
     addUniqueField(it.typ.skipTypes({tyOwned, tyRef, tyPtr}), v, d.graph.cache, d.idgen)
     vnode = indirectAccess(newSymNode(it), v, v.info)
   else:
@@ -678,14 +688,12 @@ proc closureCreationForIter(owner: PSym, iter: PNode;
     addVar(vs, vnode)
     result.add(vs)
   result.add genCreateEnv(vnode)
-  createTypeBoundOpsLL(d.graph, vnode.typ, iter.info, d.idgen, iterOwner)
+  createTypeBoundOpsLL(d.graph, vnode.typ, iter.info, d.idgen, owner)
 
   let upField = lookupInRecord(v.typ.skipTypes({tyOwned, tyRef, tyPtr}).n, getIdent(d.graph.cache, upName))
   if upField != nil:
-    let expectedUpTyp = upField.typ.skipTypes({tyOwned, tyRef, tyPtr})
-    let u = if iterOwner == owner: setupEnvVar(iterOwner, d, c, iter.info)
-            else: getUpForIter(d.graph, owner, iterOwner, expectedUpTyp)
-    if u != nil and u.typ.skipTypes({tyOwned, tyRef, tyPtr}) == expectedUpTyp:
+    let u = setupEnvVar(owner, d, c, iter.info)
+    if u.typ.skipTypes({tyOwned, tyRef, tyPtr}) == upField.typ.skipTypes({tyOwned, tyRef, tyPtr}):
       result.add(newAsgnStmt(rawIndirectAccess(vnode, upField, iter.info),
                  u, iter.info))
     else:
@@ -719,7 +727,7 @@ proc symToClosure(n: PNode; owner: PSym; d: var DetectionPass;
     let available = getHiddenParam(d.graph, owner)
     result = makeClosure(d.graph, d.idgen, s, available.newSymNode, n.info)
   elif s.isIterator:
-    result = closureCreationForIter(owner, n, d, c)
+    result = closureCreationForIter(n, d, c)
   elif s.skipGenericOwner == owner:
     # direct dependency, so use the outer's env variable:
     result = makeClosure(d.graph, d.idgen, s, setupEnvVar(owner, d, c, n.info), n.info)
@@ -766,6 +774,8 @@ proc liftCapturedVars(n: PNode; owner: PSym; d: var DetectionPass;
     elif s.id in d.capturedVars:
       if s.owner != owner:
         result = accessViaEnvParam(d.graph, n, owner)
+      elif owner.isIterator and not isDefined(d.graph.config, "nimOptIters") and interestingIterVar(s):
+        result = accessViaEnvParam(d.graph, n, owner)
       else:
         result = accessViaEnvVar(n, owner, d, c)
   of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit, nkComesFrom,
@@ -786,7 +796,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:
@@ -883,7 +893,7 @@ proc liftLambdas*(g: ModuleGraph; fn: PSym, body: PNode; tooEarly: var bool;
     # ignore forward declaration:
     result = body
     tooEarly = true
-    if fn.isIterator:
+    if fn.isIterator and isDefined(g.config, "nimOptIters"):
       var d = initDetectionPass(g, fn, idgen)
       addClosureParam(d, fn, body.info)
   else:

compiler/layeredtable.nim

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

compiler/liftdestructors.nim

@@ -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,7 +88,7 @@ proc defaultOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     body.add newAsgnStmt(x, y)
   elif c.kind == attachedDestructor and c.addMemReset:
     let call = genBuiltin(c, mDefault, "default", x)
-    call.typ() = t
+    call.typ = t
     body.add newAsgnStmt(x, call)
   elif c.kind == attachedWasMoved:
     body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
@@ -105,7 +105,7 @@ proc genWhileLoop(c: var TLiftCtx; i, dest: PNode): PNode =
   result = newNodeI(nkWhileStmt, c.info, 2)
   let cmp = genBuiltin(c, mLtI, "<", i)
   cmp.add genLen(c.g, dest)
-  cmp.typ() = getSysType(c.g, c.info, tyBool)
+  cmp.typ = getSysType(c.g, c.info, tyBool)
   result[0] = cmp
   result[1] = newNodeI(nkStmtList, c.info)
 
@@ -127,10 +127,10 @@ proc genContainerOf(c: var TLiftCtx; objType: PType, field, x: PSym): PNode =
   dotExpr.add newSymNode(field)
 
   let offsetOf = genBuiltin(c, mOffsetOf, "offsetof", dotExpr)
-  offsetOf.typ() = intType
+  offsetOf.typ = intType
 
   let minusExpr = genBuiltin(c, mSubI, "-", castExpr1)
-  minusExpr.typ() = intType
+  minusExpr.typ = intType
   minusExpr.add offsetOf
 
   let objPtr = makePtrType(objType.owner, objType, c.idgen)
@@ -265,7 +265,7 @@ proc fillBodyObjT(c: var TLiftCtx; t: PType, body, x, y: PNode) =
       # because the wasMoved(dest) call would zero out src, if dest aliases src.
       var cond = newTree(nkCall, newSymNode(c.g.getSysMagic(c.info, "==", mEqRef)),
         newTreeIT(nkAddr, c.info, makePtrType(c.fn, x.typ, c.idgen), x), newTreeIT(nkAddr, c.info, makePtrType(c.fn, y.typ, c.idgen), y))
-      cond.typ() = getSysType(c.g, x.info, tyBool)
+      cond.typ = getSysType(c.g, x.info, tyBool)
       body.add genIf(c, cond, newTreeI(nkReturnStmt, c.info, newNodeI(nkEmpty, c.info)))
     var temp = newSym(skTemp, getIdent(c.g.cache, lowerings.genPrefix), c.idgen, c.fn, c.info)
     temp.typ = x.typ
@@ -296,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}
@@ -545,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)
@@ -579,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) =
@@ -720,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))
@@ -730,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)
@@ -738,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:
@@ -765,7 +765,7 @@ proc atomicRefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     if isCyclic:
       if isFinal(elemType):
         let typInfo = genBuiltin(c, mGetTypeInfoV2, "getTypeInfoV2", newNodeIT(nkType, x.info, elemType))
-        typInfo.typ() = getSysType(c.g, c.info, tyPointer)
+        typInfo.typ = getSysType(c.g, c.info, tyPointer)
         body.add callCodegenProc(c.g, "nimTraceRef", c.info, genAddrOf(x, c.idgen), typInfo, y)
       else:
         # If the ref is polymorphic we have to account for this
@@ -786,7 +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 =
@@ -802,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:
@@ -814,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)
@@ -826,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)))
@@ -878,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))
@@ -901,14 +901,14 @@ proc closureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     # a big problem is that we don't know the environment's type here, so we
     # have to go through some indirection; we delegate this to the codegen:
     let call = newNodeI(nkCall, c.info, 2)
-    call.typ() = t
+    call.typ = t
     call[0] = newSymNode(createMagic(c.g, c.idgen, "deepCopy", mDeepCopy))
     call[1] = y
     body.add newAsgnStmt(x, call)
   elif (optOwnedRefs in c.g.config.globalOptions and
       optRefCheck in c.g.config.options) or c.g.config.selectedGC in {gcArc, gcAtomicArc, gcOrc}:
     let xx = genBuiltin(c, mAccessEnv, "accessEnv", x)
-    xx.typ() = getSysType(c.g, c.info, tyPointer)
+    xx.typ = getSysType(c.g, c.info, tyPointer)
     case c.kind
     of attachedSink:
       # we 'nil' y out afterwards so we *need* to take over its reference
@@ -917,13 +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:
@@ -938,7 +938,7 @@ proc closureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
 
 proc ownedClosureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   let xx = genBuiltin(c, mAccessEnv, "accessEnv", x)
-  xx.typ() = getSysType(c.g, c.info, tyPointer)
+  xx.typ = getSysType(c.g, c.info, tyPointer)
   var actions = newNodeI(nkStmtList, c.info)
   #discard addDestructorCall(c, elemType, newNodeI(nkStmtList, c.info), genDeref(xx))
   actions.add callCodegenProc(c.g, "nimDestroyAndDispose", c.info, xx)
@@ -1152,8 +1152,8 @@ proc symPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttachedOp
 proc genTypeFieldCopy(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   let xx = genBuiltin(c, mAccessTypeField, "accessTypeField", x)
   let yy = genBuiltin(c, mAccessTypeField, "accessTypeField", y)
-  xx.typ() = getSysType(c.g, c.info, tyPointer)
-  yy.typ() = xx.typ
+  xx.typ = getSysType(c.g, c.info, tyPointer)
+  yy.typ = xx.typ
   body.add newAsgnStmt(xx, yy)
 
 proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;

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

@@ -268,7 +268,6 @@ const
   NotesVerbosity* = computeNotesVerbosity()
   errXMustBeCompileTime* = "'$1' can only be used in compile-time context"
   errArgsNeedRunOption* = "arguments can only be given if the '--run' option is selected"
-  errFloatToString* = "cannot convert '$1' to '$2'"
 
 type
   TFileInfo* = object

compiler/linter.nim

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

compiler/lookups.nim

@@ -685,12 +685,10 @@ proc qualifiedLookUp*(c: PContext, n: PNode, flags: set[TLookupFlag]): PSym =
     var m = qualifiedLookUp(c, n[0], (flags * {checkUndeclared}) + {checkModule})
     if m != nil and m.kind == skModule:
       var ident: PIdent = nil
-      if n[1].kind == nkAccQuoted:
+      if n[1].kind == nkIdent:
+        ident = n[1].ident
+      elif n[1].kind == nkAccQuoted:
         ident = considerQuotedIdent(c, n[1])
-      else:
-        # this includes sym and symchoice nodes, but since we are looking in
-        # a module, it shouldn't matter what was captured
-        ident = n[1].getPIdent
       if ident != nil:
         if m == c.module:
           var ti: TIdentIter = default(TIdentIter)

compiler/lowerings.nim

@@ -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, idgen)
+    result.typ = makePtrType(n.typ, idgen)

compiler/modulegraphs.nim

@@ -88,7 +88,6 @@ type
     suggestMode*: bool # whether we are in nimsuggest mode or not.
     invalidTransitiveClosure: bool
     interactive*: bool
-    withinSystem*: bool # in system.nim or a module imported by system.nim
     inclToMod*: Table[FileIndex, FileIndex] # mapping of include file to the
                                             # first module that included it
     importStack*: seq[FileIndex]  # The current import stack. Used for detecting recursive

compiler/modules.nim

@@ -25,7 +25,7 @@ template getModuleIdent(graph: ModuleGraph, filename: AbsoluteFile): PIdent =
 
 proc partialInitModule*(result: PSym; graph: ModuleGraph; fileIdx: FileIndex; filename: AbsoluteFile) =
   let packSym = getPackage(graph, fileIdx)
-  setOwner(result, packSym)
+  result.owner = packSym
   result.position = int fileIdx
 
 proc newModule*(graph: ModuleGraph; fileIdx: FileIndex): PSym =

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

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

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/options.nim

@@ -229,7 +229,6 @@ type
     # alternative to above:
     genericsOpenSym
     vtables
-    typeBoundOps
 
   LegacyFeature* = enum
     allowSemcheckedAstModification,

compiler/packages.nim

@@ -51,11 +51,3 @@ func belongsToProjectPackage*(conf: ConfigRef, sym: PSym): bool =
   ## See Also:
   ## * `modulegraphs.belongsToStdlib`
   conf.mainPackageId == sym.getPackageId
-
-func belongsToProjectPackageMaybeNil*(conf: ConfigRef, sym: PSym): bool =
-  ## Return whether the symbol belongs to the project's package.
-  ## Returns `false` if `sym` is nil.
-  ##
-  ## See Also:
-  ## * `modulegraphs.belongsToStdlib`
-  sym != nil and conf.mainPackageId == sym.getPackageId

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)

compiler/pipelines.nim

@@ -47,8 +47,9 @@ proc processPipeline(graph: ModuleGraph; semNode: PNode; bModule: PPassContext):
   of NonePass:
     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) =
+proc processImplicitImports(graph: ModuleGraph; implicits: seq[string], nodeKind: TNodeKind,
+                      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):
@@ -63,7 +64,7 @@ proc processImplicitImports*(graph: ModuleGraph; implicits: seq[string], nodeKin
       if semNode == nil or processPipeline(graph, semNode, bModule) == nil:
         break
 
-proc prePass*(c: PContext; n: PNode) =
+proc prePass(c: PContext; n: PNode) =
   for son in n:
     if son.kind == nkPragma:
       for s in son:

compiler/pragmas.nim

@@ -722,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]

compiler/renderer.nim

@@ -442,11 +442,6 @@ proc atom(g: TSrcGen; n: PNode): string =
       result = $n.floatVal & "\'f64"
     else:
       result = litAux(g, n, (cast[ptr int64](addr(n.floatVal)))[], 8) & "\'f64"
-  of nkFloat128Lit:
-    if n.flags * {nfBase2, nfBase8, nfBase16} == {}:
-      result = $n.floatVal & "\'f128"
-    else:
-      result = litAux(g, n, (cast[ptr int64](addr(n.floatVal)))[], 8) & "\'f128"
   of nkNilLit: result = "nil"
   of nkType:
     if (n.typ != nil) and (n.typ.sym != nil): result = n.typ.sym.name.s
@@ -1311,11 +1306,10 @@ proc gsub(g: var TSrcGen, n: PNode, c: TContext, fromStmtList = false) =
       put(g, tkCustomLit, n[0].strVal)
       gsub(g, n, 1)
     else:
-      for i in 0..<n.len-1:
-        gsub(g, n, i)
+      gsub(g, n, 0)
       put(g, tkDot, ".")
-      if n.len > 1:
-        accentedName(g, n[^1])
+      assert n.len == 2, $n.len
+      accentedName(g, n[1])
   of nkBind:
     putWithSpace(g, tkBind, "bind")
     gsub(g, n, 0)

compiler/sem.nim

@@ -18,7 +18,7 @@ import
   evaltempl, patterns, parampatterns, sempass2, linter, semmacrosanity,
   lowerings, plugins/active, lineinfos, int128,
   isolation_check, typeallowed, modulegraphs, enumtostr, concepts, astmsgs,
-  extccomp, layeredtable
+  extccomp
 
 import vtables
 import std/[strtabs, math, tables, intsets, strutils, packedsets]
@@ -89,11 +89,6 @@ proc fitNodePostMatch(c: PContext, formal: PType, arg: PNode): PNode =
     changeType(c, x, formal, check=true)
   result = arg
   result = skipHiddenSubConv(result, c.graph, c.idgen)
-  # mark inserted converter as used:
-  var a = result
-  if a.kind == nkHiddenDeref: a = a[0]
-  if a.kind == nkHiddenCallConv and a[0].kind == nkSym:
-    markUsed(c, a.info, a[0].sym)
 
 
 proc fitNode(c: PContext, formal: PType, arg: PNode; info: TLineInfo): PNode =
@@ -102,7 +97,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 +111,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)
 
@@ -256,7 +251,7 @@ proc newSymG*(kind: TSymKind, n: PNode, c: PContext): PSym =
     # when there is a nested proc inside a template, semtmpl
     # will assign a wrong owner during the first pass over the
     # template; we must fix it here: see #909
-    setOwner(result, getCurrOwner(c))
+    result.owner = getCurrOwner(c)
   else:
     result = newSym(kind, considerQuotedIdent(c, n), c.idgen, getCurrOwner(c), n.info)
     if find(result.name.s, '`') >= 0:
@@ -470,7 +465,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:
@@ -478,7 +473,7 @@ proc semAfterMacroCall(c: PContext, call, macroResult: PNode,
         # e.g. template foo(T: typedesc): seq[T]
         # We will instantiate the return type here, because
         # we now know the supplied arguments
-        var paramTypes = initLayeredTypeMap()
+        var paramTypes = initTypeMapping()
         for param, value in genericParamsInMacroCall(s, call):
           var givenType = value.typ
           # the sym nodes used for the supplied generic arguments for
@@ -486,7 +481,7 @@ proc semAfterMacroCall(c: PContext, call, macroResult: PNode,
           # in this case, get the type directly from the sym
           if givenType == nil and value.kind == nkSym and value.sym.typ != nil:
             givenType = value.sym.typ
-          put(paramTypes, param.typ, givenType)
+          idTablePut(paramTypes, param.typ, givenType)
 
         retType = generateTypeInstance(c, paramTypes,
                                        macroResult.info, retType)
@@ -494,7 +489,7 @@ proc semAfterMacroCall(c: PContext, call, macroResult: PNode,
       if retType.kind == tyVoid:
         result = semStmt(c, result, flags)
       else:
-        result = semExpr(c, result, flags)
+        result = semExpr(c, result, flags, expectedType)
         result = fitNode(c, retType, result, result.info)
       #globalError(s.info, errInvalidParamKindX, typeToString(s.typ.returnType))
   dec(c.config.evalTemplateCounter)
@@ -502,6 +497,7 @@ proc semAfterMacroCall(c: PContext, call, macroResult: PNode,
 
 const
   errMissingGenericParamsForTemplate = "'$1' has unspecified generic parameters"
+  errFloatToString = "cannot convert '$1' to '$2'"
 
 proc semMacroExpr(c: PContext, n, nOrig: PNode, sym: PSym,
                   flags: TExprFlags = {}; expectedType: PType = nil): PNode =
@@ -612,7 +608,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"
@@ -634,7 +630,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)
@@ -647,7 +643,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:
@@ -660,7 +656,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:
@@ -675,7 +671,7 @@ proc defaultNodeField(c: PContext, a: PNode, aTyp: PType, checkDefault: bool): P
               semExprWithType(c, child),
               node
                 ))
-      result.typ() = aTyp
+      result.typ = aTyp
     else:
       result = nil
   of tyTuple:
@@ -684,7 +680,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:
@@ -733,7 +729,6 @@ 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

compiler/semcall.nim

@@ -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,23 +88,10 @@ 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
@@ -152,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:
@@ -190,14 +136,7 @@ proc pickBestCandidate(c: PContext, headSymbol: PNode,
       # 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
@@ -697,7 +636,7 @@ proc instGenericConvertersArg*(c: PContext, a: PNode, x: TCandidate) =
     if s.isGenericRoutineStrict:
       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) =
@@ -706,15 +645,6 @@ proc instGenericConvertersSons*(c: PContext, n: PNode, x: TCandidate) =
     for i in 1..<n.len:
       instGenericConvertersArg(c, n[i], x)
 
-proc markConvertersUsed*(c: PContext, n: PNode) =
-  assert n.kind in nkCallKinds
-  for i in 1..<n.len:
-    var a = n[i]
-    if a == nil: continue
-    if a.kind == nkHiddenDeref: a = a[0]
-    if a.kind == nkHiddenCallConv and a[0].kind == nkSym:
-      markUsed(c, a.info, a[0].sym)
-
 proc indexTypesMatch(c: PContext, f, a: PType, arg: PNode): PNode =
   var m = newCandidate(c, f)
   result = paramTypesMatch(m, f, a, arg, nil)
@@ -732,13 +662,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
@@ -761,7 +691,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 =
@@ -818,7 +748,7 @@ proc inheritBindings(c: PContext, x: var TCandidate, expectedType: PType) =
         if t[i] == nil or u[i] == nil: return
         stackPut(t[i], u[i])
     of tyGenericParam:
-      let prebound = x.bindings.lookup(t)
+      let prebound = x.bindings.idTableGet(t)
       if prebound != nil:
         continue # Skip param, already bound
 
@@ -830,7 +760,7 @@ proc inheritBindings(c: PContext, x: var TCandidate, expectedType: PType) =
       discard
   # update bindings
   for i in 0 ..< flatUnbound.len():
-    x.bindings.put(flatUnbound[i], flatBound[i])
+    x.bindings.idTablePut(flatUnbound[i], flatBound[i])
 
 proc semResolvedCall(c: PContext, x: var TCandidate,
                      n: PNode, flags: TExprFlags;
@@ -845,7 +775,7 @@ proc semResolvedCall(c: PContext, x: var TCandidate,
     result = x.call
     result[0] = newSymNode(finalCallee, getCallLineInfo(result[0]))
     if containsGenericType(result.typ):
-      result.typ() = newTypeS(tyError, c)
+      result.typ = newTypeS(tyError, c)
       incl result.typ.flags, tfCheckedForDestructor
     return
   let gp = finalCallee.ast[genericParamsPos]
@@ -872,17 +802,16 @@ 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
 
   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.} =
@@ -891,7 +820,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,
@@ -910,7 +839,7 @@ 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)
+      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)
@@ -925,7 +854,7 @@ proc explicitGenericInstError(c: PContext; n: PNode): PNode =
   localError(c.config, getCallLineInfo(n), errCannotInstantiateX % renderTree(n))
   result = n
 
-proc explicitGenericSym(c: PContext, n: PNode, s: PSym, errors: var CandidateErrors, doError: bool): PNode =
+proc explicitGenericSym(c: PContext, n: PNode, s: PSym): PNode =
   if s.kind in {skTemplate, skMacro}:
     internalError c.config, n.info, "cannot get explicitly instantiated symbol of " &
       (if s.kind == skTemplate: "template" else: "macro")
@@ -935,11 +864,6 @@ proc explicitGenericSym(c: PContext, n: PNode, s: PSym, errors: var CandidateErr
   if m.state != csMatch:
     # state is csMatch only if *all* generic params were matched,
     # including implicit parameters
-    if doError:
-      errors.add(CandidateError(
-        sym: s,
-        firstMismatch: m.firstMismatch,
-        diagnostics: m.diagnostics))
     return nil
   var newInst = generateInstance(c, s, m.bindings, n.info)
   newInst.typ.flags.excl tfUnresolved
@@ -959,43 +883,46 @@ 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 =
+proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym): PNode =
   assert n.kind == nkBracketExpr
   setGenericParams(c, n, s.ast[genericParamsPos])
   var s = s
   var a = n[0]
-  var errors: CandidateErrors = @[]
   if a.kind == nkSym:
     # common case; check the only candidate has the right
     # number of generic type parameters:
-    result = explicitGenericSym(c, n, s, errors, doError)
-    if doError and result == nil:
-      notFoundError(c, n, errors)
+    if s.ast[genericParamsPos].safeLen != n.len-1:
+      let expected = s.ast[genericParamsPos].safeLen
+      localError(c.config, getCallLineInfo(n), errGenerated, "cannot instantiate: '" & renderTree(n) &
+         "'; got " & $(n.len-1) & " typeof(s) but expected " & $expected)
+      return n
+    result = explicitGenericSym(c, n, s)
+    if result == nil: result = explicitGenericInstError(c, n)
   elif a.kind in {nkClosedSymChoice, nkOpenSymChoice}:
     # choose the generic proc with the proper number of type parameters.
+    # XXX I think this could be improved by reusing sigmatch.paramTypesMatch.
+    # It's good enough for now.
     result = newNodeI(a.kind, getCallLineInfo(n))
     for i in 0..<a.len:
       var candidate = a[i].sym
       if candidate.kind in {skProc, skMethod, skConverter,
                             skFunc, skIterator}:
-        let x = explicitGenericSym(c, n, candidate, errors, doError)
-        if x != nil: result.add(x)
+        # it suffices that the candidate has the proper number of generic
+        # type parameters:
+        if candidate.ast[genericParamsPos].safeLen == n.len-1:
+          let x = explicitGenericSym(c, n, candidate)
+          if x != nil: result.add(x)
     # get rid of nkClosedSymChoice if not ambiguous:
-    if result.len == 0:
-      result = nil
-      if doError:
-        notFoundError(c, n, errors)
+    if result.len == 1 and a.kind == nkClosedSymChoice:
+      result = result[0]
+    elif result.len == 0: result = explicitGenericInstError(c, n)
+    # candidateCount != 1: return explicitGenericInstError(c, n)
   else:
-    # probably unreachable: we are trying to instantiate `a` which is not
-    # a sym/symchoice
-    if doError:
-      result = explicitGenericInstError(c, n)
-    else:
-      result = nil
+    result = explicitGenericInstError(c, n)
 
 proc searchForBorrowProc(c: PContext, startScope: PScope, fn: PSym): tuple[s: PSym, state: TBorrowState] =
   # Searches for the fn in the symbol table. If the parameter lists are suitable

compiler/semdata.nim

@@ -15,8 +15,8 @@ when defined(nimPreviewSlimSystem):
   import std/assertions
 
 import
-  options, ast, msgs, idents, renderer,
-  magicsys, vmdef, modulegraphs, lineinfos, pathutils, layeredtable
+  options, ast, astalgo, msgs, idents, renderer,
+  magicsys, vmdef, modulegraphs, lineinfos, pathutils
 
 import ic / ic
 
@@ -136,13 +136,12 @@ type
     semOverloadedCall*: proc (c: PContext, n, nOrig: PNode,
                               filter: TSymKinds, flags: TExprFlags, expectedType: PType = nil): PNode {.nimcall.}
     semTypeNode*: proc(c: PContext, n: PNode, prev: PType): PType {.nimcall.}
-    semInferredLambda*: proc(c: PContext, pt: LayeredIdTable, n: PNode): PNode
-    semGenerateInstance*: proc (c: PContext, fn: PSym, pt: LayeredIdTable,
+    semInferredLambda*: proc(c: PContext, pt: Table[ItemId, PType], n: PNode): PNode
+    semGenerateInstance*: proc (c: PContext, fn: PSym, pt: Table[ItemId, PType],
                                 info: TLineInfo): PSym
-    instantiateOnlyProcType*: proc (c: PContext, pt: LayeredIdTable,
+    instantiateOnlyProcType*: proc (c: PContext, pt: TypeMapping,
                                     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
@@ -196,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")
 
@@ -450,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 =
@@ -509,7 +508,7 @@ proc errorType*(c: PContext): PType =
 
 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 =
@@ -530,11 +529,10 @@ template localErrorNode*(c: PContext, n: PNode, arg: string): PNode =
   liMessage(c.config, n2.info, errGenerated, arg, doNothing, instLoc())
   errorNode(c, n2)
 
-when false:
-  proc fillTypeS*(dest: PType, kind: TTypeKind, c: PContext) =
-    dest.kind = kind
-    dest.owner = getCurrOwner(c)
-    dest.size = - 1
+proc fillTypeS*(dest: PType, kind: TTypeKind, c: PContext) =
+  dest.kind = kind
+  dest.owner = getCurrOwner(c)
+  dest.size = - 1
 
 proc makeRangeType*(c: PContext; first, last: BiggestInt;
                     info: TLineInfo; intType: PType = nil): PType =
@@ -565,7 +563,7 @@ proc symFromType*(c: PContext; t: PType, info: TLineInfo): PSym =
 
 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}:

compiler/semexprs.nim

@@ -56,11 +56,11 @@ proc semOperand(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
   if result.typ != nil:
     if result.typ.kind in {tyVar, tyLent}: result = newDeref(result)
   elif {efWantStmt, efAllowStmt} * flags != {}:
-    result.typ() = newTypeS(tyVoid, c)
+    result.typ = newTypeS(tyVoid, c)
   else:
     localError(c.config, n.info, errExprXHasNoType %
                renderTree(result, {renderNoComments}))
-    result.typ() = errorType(c)
+    result.typ = errorType(c)
 
 proc semExprCheck(c: PContext, n: PNode, flags: TExprFlags, expectedType: PType = nil): PNode =
   rejectEmptyNode(n)
@@ -82,14 +82,14 @@ proc semExprCheck(c: PContext, n: PNode, flags: TExprFlags, expectedType: PType
 proc semExprWithType(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType = nil): PNode =
   result = semExprCheck(c, n, flags-{efTypeAllowed}, expectedType)
   if result.typ == nil and efInTypeof in flags:
-    result.typ() = c.voidType
+    result.typ = c.voidType
   elif result.typ == nil or result.typ == c.enforceVoidContext:
     localError(c.config, n.info, errExprXHasNoType %
                 renderTree(result, {renderNoComments}))
-    result.typ() = errorType(c)
+    result.typ = errorType(c)
   elif result.typ.kind == tyError:
     # associates the type error to the current owner
-    result.typ() = errorType(c)
+    result.typ = errorType(c)
   elif efTypeAllowed in flags and result.typ.kind == tyProc and
       hasUnresolvedParams(result, {}):
     # mirrored with semOperand but only on efTypeAllowed
@@ -101,7 +101,7 @@ proc semExprWithType(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType
       else:
         errProcHasNoConcreteType % n.renderTree
     localError(c.config, n.info, err)
-    result.typ() = errorType(c)
+    result.typ = errorType(c)
   else:
     if result.typ.kind in {tyVar, tyLent}: result = newDeref(result)
 
@@ -110,7 +110,7 @@ proc semExprNoDeref(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
   if result.typ == nil:
     localError(c.config, n.info, errExprXHasNoType %
                renderTree(result, {renderNoComments}))
-    result.typ() = errorType(c)
+    result.typ = errorType(c)
 
 proc semSymGenericInstantiation(c: PContext, n: PNode, s: PSym): PNode =
   result = symChoice(c, n, s, scClosed)
@@ -194,7 +194,7 @@ proc semOpenSym(c: PContext, n: PNode, flags: TExprFlags, expectedType: PType,
     result = nil
     if not isSym:
       # set symchoice node type back to None
-      n.typ() = newTypeS(tyNone, c)
+      n.typ = newTypeS(tyNone, c)
 
 proc semSymChoice(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType = nil): PNode =
   if n.kind == nkOpenSymChoice:
@@ -216,7 +216,7 @@ proc semSymChoice(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: P
       err.add "  " & candidate.owner.name.s & "." & candidate.name.s
       err.add ": " & typeToString(candidate.typ) & "\n"
     localError(c.config, n.info, err)
-    n.typ() = errorType(c)
+    n.typ = errorType(c)
     result = n
   if result.kind == nkSym:
     result = semSym(c, result, result.sym, flags)
@@ -227,7 +227,7 @@ proc inlineConst(c: PContext, n: PNode, s: PSym): PNode {.inline.} =
     localError(c.config, n.info, "constant of type '" & typeToString(s.typ) & "' has no value")
     result = newSymNode(s)
   else:
-    result.typ() = s.typ
+    result.typ = s.typ
     result.info = n.info
 
 type
@@ -395,7 +395,7 @@ proc semConv(c: PContext, n: PNode; flags: TExprFlags = {}, expectedType: PType
     var evaluated = semStaticExpr(c, n[1], expectedType)
     if evaluated.kind == nkType or evaluated.typ.kind == tyTypeDesc:
       result = n
-      result.typ() = c.makeTypeDesc semStaticType(c, evaluated, nil)
+      result.typ = c.makeTypeDesc semStaticType(c, evaluated, nil)
       return
     elif targetType.base.kind == tyNone:
       return evaluated
@@ -413,7 +413,7 @@ proc semConv(c: PContext, n: PNode; flags: TExprFlags = {}, expectedType: PType
     if targetType.kind == tyOwned:
       t.flags.incl tfHasOwned
     result = newNodeI(nkType, n.info)
-    result.typ() = makeTypeDesc(c, t)
+    result.typ = makeTypeDesc(c, t)
     return
 
   result.add copyTree(n[0])
@@ -429,10 +429,10 @@ proc semConv(c: PContext, n: PNode; flags: TExprFlags = {}, expectedType: PType
   if targetType.kind != tyGenericParam and targetType.isMetaType:
     let final = inferWithMetatype(c, targetType, op, true)
     result.add final
-    result.typ() = final.typ
+    result.typ = final.typ
     return
 
-  result.typ() = targetType
+  result.typ = targetType
   # XXX op is overwritten later on, this is likely added too early
   # here or needs to be overwritten too then.
   result.add op
@@ -440,7 +440,7 @@ proc semConv(c: PContext, n: PNode; flags: TExprFlags = {}, expectedType: PType
   if targetType.kind == tyGenericParam or
       (op.typ != nil and op.typ.kind == tyFromExpr and c.inGenericContext > 0):
     # expression is compiled early in a generic body
-    result.typ() = makeTypeFromExpr(c, copyTree(result))
+    result.typ = makeTypeFromExpr(c, copyTree(result))
     return result
 
   if not isSymChoice(op):
@@ -490,7 +490,7 @@ proc semCast(c: PContext, n: PNode): PNode =
   if not isCastable(c, targetType, castedExpr.typ, n.info):
     localError(c.config, n.info, "expression cannot be cast to '$1'" % $targetType)
   result = newNodeI(nkCast, n.info)
-  result.typ() = targetType
+  result.typ = targetType
   result.add copyTree(n[0])
   result.add castedExpr
 
@@ -504,18 +504,18 @@ proc semLowHigh(c: PContext, n: PNode, m: TMagic): PNode =
     var typ = skipTypes(n[1].typ, abstractVarRange + {tyTypeDesc, tyUserTypeClassInst})
     case typ.kind
     of tySequence, tyString, tyCstring, tyOpenArray, tyVarargs:
-      n.typ() = getSysType(c.graph, n.info, tyInt)
+      n.typ = getSysType(c.graph, n.info, tyInt)
     of tyArray:
-      n.typ() = typ.indexType
+      n.typ = typ.indexType
       if n.typ.kind == tyRange and emptyRange(n.typ.n[0], n.typ.n[1]): #Invalid range
-        n.typ() = getSysType(c.graph, n.info, tyInt)
+        n.typ = getSysType(c.graph, n.info, tyInt)
     of tyInt..tyInt64, tyChar, tyBool, tyEnum, tyUInt..tyUInt64, tyFloat..tyFloat64:
-      n.typ() = n[1].typ.skipTypes({tyTypeDesc})
+      n.typ = n[1].typ.skipTypes({tyTypeDesc})
     of tyGenericParam:
       # prepare this for resolving in semtypinst:
       # we must use copyTree here in order to avoid creating a cycle
       # that could easily turn into an infinite recursion in semtypinst
-      n.typ() = makeTypeFromExpr(c, n.copyTree)
+      n.typ = makeTypeFromExpr(c, n.copyTree)
     else:
       localError(c.config, n.info, "invalid argument for: " & opToStr[m])
   result = n
@@ -531,7 +531,7 @@ proc fixupStaticType(c: PContext, n: PNode) =
   # apply this measure only in code that is enlightened to work
   # with static types.
   if n.typ.kind != tyStatic:
-    n.typ() = newTypeS(tyStatic, c, n.typ)
+    n.typ = newTypeS(tyStatic, c, n.typ)
     n.typ.n = n # XXX: cycles like the one here look dangerous.
                 # Consider using `n.copyTree`
 
@@ -581,7 +581,7 @@ proc isOpImpl(c: PContext, n: PNode, flags: TExprFlags): PNode =
     # `res = sameType(t1, t2)` would be wrong, e.g. for `int is (int|float)`
 
   result = newIntNode(nkIntLit, ord(res))
-  result.typ() = n.typ
+  result.typ = n.typ
 
 proc semIs(c: PContext, n: PNode, flags: TExprFlags): PNode =
   if n.len != 3 or n[2].kind == nkEmpty:
@@ -590,7 +590,7 @@ proc semIs(c: PContext, n: PNode, flags: TExprFlags): PNode =
 
   let boolType = getSysType(c.graph, n.info, tyBool)
   result = n
-  n.typ() = boolType
+  n.typ = boolType
   var liftLhs = true
 
   n[1] = semExprWithType(c, n[1], {efDetermineType, efWantIterator})
@@ -604,7 +604,7 @@ proc semIs(c: PContext, n: PNode, flags: TExprFlags): PNode =
         n[1] = evaluated
       else:
         result = newIntNode(nkIntLit, 0)
-        result.typ() = boolType
+        result.typ = boolType
         return
     elif t2.kind == tyTypeDesc and
         (t2.base.kind == tyNone or tfExplicit in t2.flags):
@@ -634,7 +634,7 @@ proc semOpAux(c: PContext, n: PNode) =
       let info = a[0].info
       a[0] = newIdentNode(considerQuotedIdent(c, a[0], a), info)
       a[1] = semExprWithType(c, a[1], flags)
-      a.typ() = a[1].typ
+      a.typ = a[1].typ
     else:
       n[i] = semExprWithType(c, a, flags)
 
@@ -707,7 +707,7 @@ proc changeType(c: PContext; n: PNode, newType: PType, check: bool) =
         localError(c.config, n.info, "cannot convert '" & n.sym.name.s &
                                          "' to '" & typeNameAndDesc(newType) & "'")
   else: discard
-  n.typ() = newType
+  n.typ = newType
 
 proc arrayConstrType(c: PContext, n: PNode): PType =
   var typ = newTypeS(tyArray, c)
@@ -722,41 +722,29 @@ proc arrayConstrType(c: PContext, n: PNode): PType =
 
 proc semArrayConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType = nil): PNode =
   result = newNodeI(nkBracket, n.info)
-  # nkBracket nodes can also be produced by the VM as seq constant nodes
-  # in which case, we cannot produce a new array type for the node,
-  # as this might lose type info even when the node has array type
-  let constructType = n.typ.isNil
+  result.typ = newTypeS(tyArray, c)
   var expectedElementType, expectedIndexType: PType = nil
-  var expectedBase: PType = nil
-  if constructType:
-    result.typ() = newTypeS(tyArray, c)
-    rawAddSon(result.typ, nil)     # index type
-    if expectedType != nil:
-      expectedBase = expectedType.skipTypes(abstractRange-{tyDistinct})
-  else:
-    result.typ() = n.typ
-    expectedBase = n.typ.skipTypes(abstractRange) # include tyDistinct this time
-  if expectedBase != nil:
-    case expectedBase.kind
+  if expectedType != nil:
+    let expected = expectedType.skipTypes(abstractRange-{tyDistinct})
+    case expected.kind
     of tyArray:
-      expectedIndexType = expectedBase[0]
-      expectedElementType = expectedBase[1]
-    of tyOpenArray, tySequence:
-      # typed bracket expressions can also have seq type
-      expectedElementType = expectedBase[0]
+      expectedIndexType = expected[0]
+      expectedElementType = expected[1]
+    of tyOpenArray:
+      expectedElementType = expected[0]
     else: discard
+  rawAddSon(result.typ, nil)     # index type
   var
     firstIndex, lastIndex: Int128 = Zero
     indexType = getSysType(c.graph, n.info, tyInt)
     lastValidIndex = lastOrd(c.config, indexType)
   if n.len == 0:
-    if constructType:
-      rawAddSon(result.typ,
-        if expectedElementType != nil and
-            typeAllowed(expectedElementType, skLet, c) == nil:
-          expectedElementType
-        else:
-          newTypeS(tyEmpty, c)) # needs an empty basetype!
+    rawAddSon(result.typ,
+      if expectedElementType != nil and
+          typeAllowed(expectedElementType, skLet, c) == nil:
+        expectedElementType
+      else:
+        newTypeS(tyEmpty, c)) # needs an empty basetype!
     lastIndex = toInt128(-1)
   else:
     var x = n[0]
@@ -773,13 +761,9 @@ proc semArrayConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PTyp
         x = x[1]
 
     let yy = semExprWithType(c, x, {efTypeAllowed}, expectedElementType)
-    var typ: PType
-    if constructType:
-      typ = yy.typ
-      if expectedElementType == nil:
-        expectedElementType = typ
-    else:
-      typ = expectedElementType
+    var typ = yy.typ
+    if expectedElementType == nil:
+      expectedElementType = typ
     result.add yy
     #var typ = skipTypes(result[0].typ, {tyGenericInst, tyVar, tyLent, tyOrdinal})
     for i in 1..<n.len:
@@ -799,20 +783,15 @@ proc semArrayConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PTyp
 
       let xx = semExprWithType(c, x, {efTypeAllowed}, expectedElementType)
       result.add xx
-      if constructType:
-        typ = commonType(c, typ, xx.typ)
+      typ = commonType(c, typ, xx.typ)
       #n[i] = semExprWithType(c, x, {})
       #result.add fitNode(c, typ, n[i])
       inc(lastIndex)
-    if constructType:
-      addSonSkipIntLit(result.typ, typ, c.idgen)
+    addSonSkipIntLit(result.typ, typ, c.idgen)
     for i in 0..<result.len:
       result[i] = fitNode(c, typ, result[i], result[i].info)
-  if constructType:
-    result.typ.setIndexType(
-      makeRangeType(c,
-        toInt64(firstIndex), toInt64(lastIndex),
-        n.info, indexType))
+  result.typ.setIndexType makeRangeType(c, toInt64(firstIndex), toInt64(lastIndex), n.info,
+                                     indexType)
 
 proc fixAbstractType(c: PContext, n: PNode) =
   for i in 1..<n.len:
@@ -911,9 +890,6 @@ proc analyseIfAddressTaken(c: PContext, n: PNode, isOutParam: bool): PNode =
 
 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, mAppendStrCh, mAppendStrStr, mSwap,
@@ -1002,13 +978,13 @@ proc evalAtCompileTime(c: PContext, n: PNode): PNode =
         if n[i].typ.isNil or n[i].typ.kind != tyStatic or
             tfUnresolved notin n[i].typ.flags:
           break maybeLabelAsStatic
-      n.typ() = newTypeS(tyStatic, c, n.typ)
+      n.typ = newTypeS(tyStatic, c, n.typ)
       n.typ.flags.incl tfUnresolved
 
   # optimization pass: not necessary for correctness of the semantic pass
-  if (callee.kind == skConst or
+  if callee.kind == skConst or
      {sfNoSideEffect, sfCompileTime} * callee.flags != {} and
-     {sfForward, sfImportc} * callee.flags == {}) and n.typ != nil:
+     {sfForward, sfImportc} * callee.flags == {} and n.typ != nil:
 
     if callee.kind != skConst and
        sfCompileTime notin callee.flags and
@@ -1091,7 +1067,7 @@ proc semOverloadedCallAnalyseEffects(c: PContext, n: PNode, nOrig: PNode,
         if efWantIterable in flags:
           let typ = newTypeS(tyIterable, c)
           rawAddSon(typ, result.typ)
-          result.typ() = typ
+          result.typ = typ
 
 proc resolveIndirectCall(c: PContext; n, nOrig: PNode;
                          t: PType): TCandidate =
@@ -1178,7 +1154,7 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType
     elif n0.typ.kind == tyFromExpr and c.inGenericContext > 0:
       # don't make assumptions, entire expression needs to be tyFromExpr
       result = semGenericStmt(c, n)
-      result.typ() = makeTypeFromExpr(c, result.copyTree)
+      result.typ = makeTypeFromExpr(c, result.copyTree)
       return
     else:
       n[0] = n0
@@ -1236,7 +1212,6 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType
     else:
       result = m.call
       instGenericConvertersSons(c, result, m)
-      markConvertersUsed(c, result)
 
   else:
     result = overloadedCallOpr(c, n) # this uses efNoUndeclared
@@ -1436,7 +1411,7 @@ proc semSym(c: PContext, n: PNode, sym: PSym, flags: TExprFlags): PNode =
     of tyStatic:
       if typ.n != nil:
         result = typ.n
-        result.typ() = typ.base
+        result.typ = typ.base
       else:
         result = newSymNode(s, n.info)
     else:
@@ -1482,22 +1457,20 @@ proc semSym(c: PContext, n: PNode, sym: PSym, flags: TExprFlags): PNode =
     onUse(n.info, s)
     if s.typ.kind == tyStatic:
       result = newSymNode(s, n.info)
-      result.typ() = s.typ
+      result.typ = s.typ
     elif s.ast != nil:
       result = semExpr(c, s.ast)
     else:
-      n.typ() = s.typ
+      n.typ = s.typ
       return n
   of skType:
     if n.kind != nkDotExpr: # dotExpr is already checked by builtinFieldAccess
       markUsed(c, n.info, s)
     onUse(n.info, s)
-    if s.typ == nil:
-      return localErrorNode(c, n, "symbol '$1' has no type" % [s.name.s])
     if s.typ.kind == tyStatic and s.typ.base.kind != tyNone and s.typ.n != nil:
       return s.typ.n
     result = newSymNode(s, n.info)
-    result.typ() = makeTypeDesc(c, s.typ)
+    result.typ = makeTypeDesc(c, s.typ)
   of skField:
     # old code, not sure if it's live code:
     markUsed(c, n.info, s)
@@ -1523,7 +1496,7 @@ proc tryReadingGenericParam(c: PContext, n: PNode, i: PIdent, t: PType): PNode =
     if result == c.graph.emptyNode:
       if c.inGenericContext > 0:
         result = semGenericStmt(c, n)
-        result.typ() = makeTypeFromExpr(c, result.copyTree)
+        result.typ = makeTypeFromExpr(c, result.copyTree)
       else:
         result = nil
   of tyUserTypeClasses:
@@ -1531,7 +1504,7 @@ proc tryReadingGenericParam(c: PContext, n: PNode, i: PIdent, t: PType): PNode =
       result = readTypeParameter(c, t, i, n.info)
     elif c.inGenericContext > 0:
       result = semGenericStmt(c, n)
-      result.typ() = makeTypeFromExpr(c, copyTree(result))
+      result.typ = makeTypeFromExpr(c, copyTree(result))
     else:
       result = nil
   of tyGenericBody, tyCompositeTypeClass:
@@ -1540,12 +1513,12 @@ proc tryReadingGenericParam(c: PContext, n: PNode, i: PIdent, t: PType): PNode =
       if result != nil:
         # generic parameter exists, stop here but delay until instantiation
         result = semGenericStmt(c, n)
-        result.typ() = makeTypeFromExpr(c, copyTree(result))
+        result.typ = makeTypeFromExpr(c, copyTree(result))
     else:
       result = nil
   elif c.inGenericContext > 0 and t.containsUnresolvedType:
     result = semGenericStmt(c, n)
-    result.typ() = makeTypeFromExpr(c, copyTree(result))
+    result.typ = makeTypeFromExpr(c, copyTree(result))
   else:
     result = nil
 
@@ -1563,14 +1536,14 @@ proc tryReadingTypeField(c: PContext, n: PNode, i: PIdent, ty: PType): PNode =
     if f != nil:
       result = newSymNode(f)
       result.info = n.info
-      result.typ() = ty
+      result.typ = ty
       markUsed(c, n.info, f)
       onUse(n.info, f)
   of tyObject, tyTuple:
     if ty.n != nil and ty.n.kind == nkRecList:
       let field = lookupInRecord(ty.n, i)
       if field != nil:
-        n.typ() = makeTypeDesc(c, field.typ)
+        n.typ = makeTypeDesc(c, field.typ)
         result = n
   of tyGenericInst:
     result = tryReadingTypeField(c, n, i, ty.skipModifier)
@@ -1617,7 +1590,7 @@ proc builtinFieldAccess(c: PContext; n: PNode; flags: var TExprFlags): PNode =
       # tyFromExpr, but when this happen in a macro this is not a built-in
       # field access and we leave the compiler to compile a normal call:
       if getCurrOwner(c).kind != skMacro:
-        n.typ() = makeTypeFromExpr(c, n.copyTree)
+        n.typ = makeTypeFromExpr(c, n.copyTree)
         flags.incl efCannotBeDotCall
         return n
       else:
@@ -1657,12 +1630,12 @@ proc builtinFieldAccess(c: PContext; n: PNode; flags: var TExprFlags): PNode =
         n[0] = makeDeref(n[0])
         n[1] = newSymNode(f) # we now have the correct field
         n[1].info = info # preserve the original info
-        n.typ() = f.typ
+        n.typ = f.typ
         if check == nil:
           result = n
         else:
           check[0] = n
-          check.typ() = n.typ
+          check.typ = n.typ
           result = check
   elif ty.kind == tyTuple and ty.n != nil:
     f = getSymFromList(ty.n, i)
@@ -1671,7 +1644,7 @@ proc builtinFieldAccess(c: PContext; n: PNode; flags: var TExprFlags): PNode =
       onUse(n[1].info, f)
       n[0] = makeDeref(n[0])
       n[1] = newSymNode(f)
-      n.typ() = f.typ
+      n.typ = f.typ
       result = n
 
   # we didn't find any field, let's look for a generic param
@@ -1720,21 +1693,33 @@ proc semDeref(c: PContext, n: PNode, flags: TExprFlags): PNode =
   result = n
   var t = skipTypes(n[0].typ, {tyGenericInst, tyVar, tyLent, tyAlias, tySink, tyOwned})
   case t.kind
-  of tyRef, tyPtr: n.typ() = t.elementType
+  of tyRef, tyPtr: n.typ = t.elementType
   of tyMetaTypes, tyFromExpr:
-    n.typ() = makeTypeFromExpr(c, n.copyTree)
+    n.typ = makeTypeFromExpr(c, n.copyTree)
   else: result = nil
   #GlobalError(n[0].info, errCircumNeedsPointer)
 
-proc maybeInstantiateGeneric(c: PContext, n: PNode, s: PSym, doError: bool): PNode =
-  ## Attempts to instantiate generic proc symbol(s) with given parameters.
-  ## If instantiation causes errors; if `doError` is `true`, a type mismatch
-  ## error is given, otherwise `nil` is returned.
-  result = explicitGenericInstantiation(c, n, s, doError)
-  if result == n:
-    n[0] = copyTree(result[0])
+proc maybeInstantiateGeneric(c: PContext, n: PNode, s: PSym): PNode =
+  ## Instantiates generic if not lacking implicit generics,
+  ## otherwise returns n.
+  let
+    neededGenParams = s.ast[genericParamsPos].len
+    heldGenParams = n.len - 1
+  var implicitParams = 0
+  for x in s.ast[genericParamsPos]:
+    if tfImplicitTypeParam in x.typ.flags:
+      inc implicitParams
+  if heldGenParams != neededGenParams and implicitParams + heldGenParams == neededGenParams:
+    # This is an implicit + explicit generic procedure without all args passed,
+    # kicking back the sem'd symbol fixes #17212
+    # Uncertain the hackiness of this solution.
+    result = n
+  else:
+    result = explicitGenericInstantiation(c, n, s)
+    if result == n:
+      n[0] = copyTree(result[0])
 
-proc semSubscript(c: PContext, n: PNode, flags: TExprFlags, afterOverloading = false): PNode =
+proc semSubscript(c: PContext, n: PNode, flags: TExprFlags): PNode =
   ## returns nil if not a built-in subscript operator; also called for the
   ## checking of assignments
   result = nil
@@ -1755,10 +1740,10 @@ proc semSubscript(c: PContext, n: PNode, flags: TExprFlags, afterOverloading = f
   if arr.kind == tyStatic:
     if arr.base.kind == tyNone:
       result = n
-      result.typ() = semStaticType(c, n[1], nil)
+      result.typ = semStaticType(c, n[1], nil)
       return
     elif arr.n != nil:
-      return semSubscript(c, arr.n, flags, afterOverloading)
+      return semSubscript(c, arr.n, flags)
     else:
       arr = arr.base
 
@@ -1777,18 +1762,18 @@ proc semSubscript(c: PContext, n: PNode, flags: TExprFlags, afterOverloading = f
       if arg != nil:
         n[1] = arg
         result = n
-        result.typ() = elemType(arr)
+        result.typ = elemType(arr)
     # Other types have a bit more of leeway
     elif n[1].typ.skipTypes(abstractRange-{tyDistinct}).kind in
         {tyInt..tyInt64, tyUInt..tyUInt64}:
       result = n
-      result.typ() = elemType(arr)
+      result.typ = elemType(arr)
   of tyTypeDesc:
     # The result so far is a tyTypeDesc bound
     # a tyGenericBody. The line below will substitute
     # it with the instantiated type.
     result = n
-    result.typ() = makeTypeDesc(c, semTypeNode(c, n, nil))
+    result.typ = makeTypeDesc(c, semTypeNode(c, n, nil))
     #result = symNodeFromType(c, semTypeNode(c, n, nil), n.info)
   of tyTuple:
     if n.len != 2: return nil
@@ -1798,7 +1783,7 @@ proc semSubscript(c: PContext, n: PNode, flags: TExprFlags, afterOverloading = f
     if skipTypes(n[1].typ, {tyGenericInst, tyRange, tyOrdinal, tyAlias, tySink}).kind in
         {tyInt..tyInt64}:
       let idx = getOrdValue(n[1])
-      if idx >= 0 and idx < arr.len: n.typ() = arr[toInt(idx)]
+      if idx >= 0 and idx < arr.len: n.typ = arr[toInt(idx)]
       else:
         localError(c.config, n.info,
           "invalid index $1 in subscript for tuple of length $2" %
@@ -1815,10 +1800,7 @@ proc semSubscript(c: PContext, n: PNode, flags: TExprFlags, afterOverloading = f
       of skProc, skFunc, skMethod, skConverter, skIterator:
         # type parameters: partial generic specialization
         n[0] = semSymGenericInstantiation(c, n[0], s)
-        result = maybeInstantiateGeneric(c, n, s, doError = afterOverloading)
-        if result != nil:
-          # check newly created sym/symchoice
-          result = semExpr(c, result, flags)
+        result = maybeInstantiateGeneric(c, n, s)
       of skMacro, skTemplate:
         if efInCall in flags:
           # We are processing macroOrTmpl[] in macroOrTmpl[](...) call.
@@ -1893,7 +1875,7 @@ proc takeImplicitAddr(c: PContext, n: PNode; isLent: bool): PNode =
       localError(c.config, n.info, errExprHasNoAddress)
   result = newNodeIT(nkHiddenAddr, n.info, if n.typ.kind in {tyVar, tyLent}: n.typ else: makePtrType(c, n.typ))
   if n.typ.kind in {tyVar, tyLent}:
-    n.typ() = n.typ.elementType
+    n.typ = n.typ.elementType
   result.add(n)
 
 proc asgnToResultVar(c: PContext, n, le, ri: PNode) {.inline.} =
@@ -2061,7 +2043,7 @@ proc semAsgn(c: PContext, n: PNode; mode=asgnNormal): PNode =
     let lhs = n[0]
     let rhs = semExprWithType(c, n[1], {efTypeAllowed}, le)
     if lhs.kind == nkSym and lhs.sym.kind == skResult:
-      n.typ() = c.enforceVoidContext
+      n.typ = c.enforceVoidContext
       if c.p.owner.kind != skMacro and resultTypeIsInferrable(lhs.sym.typ):
         var rhsTyp = rhs.typ
         if rhsTyp.kind in tyUserTypeClasses and rhsTyp.isResolvedUserTypeClass:
@@ -2072,7 +2054,7 @@ proc semAsgn(c: PContext, n: PNode; mode=asgnNormal): PNode =
           internalAssert c.config, c.p.resultSym != nil
           # Make sure the type is valid for the result variable
           typeAllowedCheck(c, n.info, rhsTyp, skResult)
-          lhs.typ() = rhsTyp
+          lhs.typ = rhsTyp
           c.p.resultSym.typ = rhsTyp
           c.p.owner.typ.setReturnType rhsTyp
         else:
@@ -2120,7 +2102,7 @@ proc semProcBody(c: PContext, n: PNode; expectedType: PType = nil): PNode =
     if result.kind == nkNilLit:
       # or ImplicitlyDiscardable(result):
       # new semantic: 'result = x' triggers the void context
-      result.typ() = nil
+      result.typ = nil
     elif result.kind == nkStmtListExpr and result.typ.kind == tyNil:
       # to keep backwards compatibility bodies like:
       #   nil
@@ -2223,7 +2205,7 @@ proc semDefined(c: PContext, n: PNode): PNode =
   result = newIntNode(nkIntLit, 0)
   result.intVal = ord isDefined(c.config, considerQuotedIdentOrDot(c, n[1], n).s)
   result.info = n.info
-  result.typ() = getSysType(c.graph, n.info, tyBool)
+  result.typ = getSysType(c.graph, n.info, tyBool)
 
 proc lookUpForDeclared(c: PContext, n: PNode, onlyCurrentScope: bool): PSym =
   case n.kind
@@ -2261,7 +2243,7 @@ proc semDeclared(c: PContext, n: PNode, onlyCurrentScope: bool): PNode =
   result = newIntNode(nkIntLit, 0)
   result.intVal = ord lookUpForDeclared(c, n[1], onlyCurrentScope) != nil
   result.info = n.info
-  result.typ() = getSysType(c.graph, n.info, tyBool)
+  result.typ = getSysType(c.graph, n.info, tyBool)
 
 proc expectMacroOrTemplateCall(c: PContext, n: PNode): PSym =
   ## The argument to the proc should be nkCall(...) or similar
@@ -2334,10 +2316,10 @@ proc semExpandToAst(c: PContext, n: PNode): PNode =
     localError(c.config, n.info, "getAst takes a call, but got " & n.renderTree)
   # Preserve the magic symbol in order to be handled in evals.nim
   internalAssert c.config, n[0].sym.magic == mExpandToAst
-  #n.typ() = getSysSym("NimNode").typ # expandedSym.getReturnType
+  #n.typ = getSysSym("NimNode").typ # expandedSym.getReturnType
   if n.kind == nkStmtList and n.len == 1: result = n[0]
   else: result = n
-  result.typ() = sysTypeFromName(c.graph, n.info, "NimNode")
+  result.typ = sysTypeFromName(c.graph, n.info, "NimNode")
 
 proc semExpandToAst(c: PContext, n: PNode, magicSym: PSym,
                     flags: TExprFlags = {}): PNode =
@@ -2507,7 +2489,7 @@ proc semCompiles(c: PContext, n: PNode, flags: TExprFlags): PNode =
 
   result = newIntNode(nkIntLit, ord(tryExpr(c, n[1], flags) != nil))
   result.info = n.info
-  result.typ() = getSysType(c.graph, n.info, tyBool)
+  result.typ = getSysType(c.graph, n.info, tyBool)
 
 proc semShallowCopy(c: PContext, n: PNode, flags: TExprFlags): PNode =
   if n.len == 3:
@@ -2531,8 +2513,8 @@ proc instantiateCreateFlowVarCall(c: PContext; t: PType;
   let sym = magicsys.getCompilerProc(c.graph, "nimCreateFlowVar")
   if sym == nil:
     localError(c.config, info, "system needs: nimCreateFlowVar")
-  var bindings = initLayeredTypeMap()
-  bindings.put(sym.ast[genericParamsPos][0].typ, t)
+  var bindings = initTypeMapping()
+  bindings.idTablePut(sym.ast[genericParamsPos][0].typ, t)
   result = c.semGenerateInstance(c, sym, bindings, info)
   # since it's an instantiation, we unmark it as a compilerproc. Otherwise
   # codegen would fail:
@@ -2551,7 +2533,7 @@ proc semSizeof(c: PContext, n: PNode): PNode =
   else:
     n[1] = semExprWithType(c, n[1], {efDetermineType})
     #restoreOldStyleType(n[1])
-  n.typ() = getSysType(c.graph, n.info, tyInt)
+  n.typ = getSysType(c.graph, n.info, tyInt)
   result = foldSizeOf(c.config, n, n)
 
 proc semMagic(c: PContext, n: PNode, s: PSym, flags: TExprFlags; expectedType: PType = nil): PNode =
@@ -2593,7 +2575,7 @@ proc semMagic(c: PContext, n: PNode, s: PSym, flags: TExprFlags; expectedType: P
     markUsed(c, n.info, s)
     checkSonsLen(n, 2, c.config)
     result = newStrNodeT(renderTree(n[1], {renderNoComments}), n, c.graph)
-    result.typ() = getSysType(c.graph, n.info, tyString)
+    result.typ = getSysType(c.graph, n.info, tyString)
   of mParallel:
     markUsed(c, n.info, s)
     if parallel notin c.features:
@@ -2619,9 +2601,9 @@ proc semMagic(c: PContext, n: PNode, s: PSym, flags: TExprFlags; expectedType: P
       let typ = result[^1].typ
       if not typ.isEmptyType:
         if spawnResult(typ, c.inParallelStmt > 0) == srFlowVar:
-          result.typ() = createFlowVar(c, typ, n.info)
+          result.typ = createFlowVar(c, typ, n.info)
         else:
-          result.typ() = typ
+          result.typ = typ
         result.add instantiateCreateFlowVarCall(c, typ, n.info).newSymNode
       else:
         result.add c.graph.emptyNode
@@ -2629,7 +2611,7 @@ proc semMagic(c: PContext, n: PNode, s: PSym, flags: TExprFlags; expectedType: P
     markUsed(c, n.info, s)
     result = setMs(n, s)
     result[1] = semExpr(c, n[1])
-    result.typ() = n[1].typ
+    result.typ = n[1].typ
   of mPlugin:
     markUsed(c, n.info, s)
     # semDirectOp with conditional 'afterCallActions':
@@ -2760,18 +2742,18 @@ proc semWhen(c: PContext, n: PNode, semCheck = true): PNode =
     else: illFormedAst(n, c.config)
   if cannotResolve:
     result = semGenericStmt(c, n)
-    result.typ() = makeTypeFromExpr(c, result.copyTree)
+    result.typ = makeTypeFromExpr(c, result.copyTree)
     return
   if result == nil:
     result = newNodeI(nkEmpty, n.info)
   if whenNimvm:
-    result.typ() = typ
+    result.typ = typ
     if n.len == 1:
       result.add(newTree(nkElse, newNode(nkStmtList)))
 
 proc semSetConstr(c: PContext, n: PNode, expectedType: PType = nil): PNode =
   result = newNodeI(nkCurly, n.info)
-  result.typ() = newTypeS(tySet, c)
+  result.typ = newTypeS(tySet, c)
   result.typ.flags.incl tfIsConstructor
   var expectedElementType: PType = nil
   if expectedType != nil and (
@@ -2797,7 +2779,7 @@ proc semSetConstr(c: PContext, n: PNode, expectedType: PType = nil): PNode =
         if doSetType:
           typ = skipTypes(n[i][1].typ,
                           {tyGenericInst, tyVar, tyLent, tyOrdinal, tyAlias, tySink})
-        n[i].typ() = n[i][2].typ # range node needs type too
+        n[i].typ = n[i][2].typ # range node needs type too
       elif n[i].kind == nkRange:
         # already semchecked
         if doSetType:
@@ -2912,7 +2894,7 @@ proc semTupleFieldsConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType
 
     if n[i][1].typ.kind == tyTypeDesc:
       localError(c.config, n[i][1].info, "typedesc not allowed as tuple field.")
-      n[i][1].typ() = errorType(c)
+      n[i][1].typ = errorType(c)
 
     var f = newSymS(skField, n[i][0], c)
     f.typ = skipIntLit(n[i][1].typ.skipTypes({tySink}), c.idgen)
@@ -2921,7 +2903,7 @@ proc semTupleFieldsConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType
     typ.n.add newSymNode(f)
     n[i][0] = newSymNode(f)
     result.add n[i]
-  result.typ() = typ
+  result.typ = typ
 
 proc semTuplePositionsConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType = nil): PNode =
   result = n                  # we don't modify n, but compute the type:
@@ -2942,7 +2924,7 @@ proc semTuplePositionsConstr(c: PContext, n: PNode, flags: TExprFlags; expectedT
       # `const foo = if true: (0, nil) else: (1, new(int))`
       n[i] = fitNode(c, expectedElemType, n[i], n[i].info)
     addSonSkipIntLit(typ, n[i].typ.skipTypes({tySink}), c.idgen)
-  result.typ() = typ
+  result.typ = typ
 
 include semobjconstr
 
@@ -2958,13 +2940,13 @@ proc semBlock(c: PContext, n: PNode; flags: TExprFlags; expectedType: PType = ni
     if sfGenSym notin labl.flags:
       addDecl(c, labl)
     elif labl.owner == nil:
-      setOwner(labl, c.p.owner)
+      labl.owner = c.p.owner
     n[0] = newSymNode(labl, n[0].info)
     suggestSym(c.graph, n[0].info, labl, c.graph.usageSym)
     styleCheckDef(c, labl)
     onDef(n[0].info, labl)
   n[1] = semExpr(c, n[1], flags, expectedType)
-  n.typ() = n[1].typ
+  n.typ = n[1].typ
   if isEmptyType(n.typ): n.transitionSonsKind(nkBlockStmt)
   else: n.transitionSonsKind(nkBlockExpr)
   closeScope(c)
@@ -3042,7 +3024,7 @@ proc semTupleConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PTyp
   if isTupleType: # expressions as ``(int, string)`` are reinterpret as type expressions
     result = n
     var typ = semTypeNode(c, n, nil).skipTypes({tyTypeDesc})
-    result.typ() = makeTypeDesc(c, typ)
+    result.typ = makeTypeDesc(c, typ)
   else:
     result = tupexp
 
@@ -3264,10 +3246,10 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType
       if expectedType != nil and (
           let expected = expectedType.skipTypes(abstractRange-{tyDistinct});
           expected.kind == typeKind):
-        result.typ() = expected
+        result.typ = expected
         changeType(c, result, expectedType, check=true)
       else:
-        result.typ() = getSysType(c.graph, n.info, typeKind)
+        result.typ = getSysType(c.graph, n.info, typeKind)
 
   result = n
   when defined(nimsuggest):
@@ -3302,7 +3284,7 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType
         #   localError(c.config, n.info, errInstantiateXExplicitly, s.name.s)
       # "procs literals" are 'owned'
       if optOwnedRefs in c.config.globalOptions:
-        result.typ() = makeVarType(c, result.typ, tyOwned)
+        result.typ = makeVarType(c, result.typ, tyOwned)
     of skEnumField:
       result = enumFieldSymChoice(c, n, s, flags)
     else:
@@ -3331,11 +3313,11 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType
     discard
   of nkNilLit:
     if result.typ == nil:
-      result.typ() = getNilType(c)
+      result.typ = getNilType(c)
       if expectedType != nil and expectedType.kind notin {tyUntyped, tyTyped}:
         var m = newCandidate(c, result.typ)
         if typeRel(m, expectedType, result.typ) >= isSubtype:
-          result.typ() = expectedType
+          result.typ = expectedType
         # or: result = fitNode(c, expectedType, result, n.info)
   of nkIntLit:
     if result.typ == nil:
@@ -3363,10 +3345,10 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType
       if expectedType != nil and (
           let expected = expectedType.skipTypes(abstractRange-{tyDistinct});
           expected.kind in {tyFloat..tyFloat128}):
-        result.typ() = expected
+        result.typ = expected
         changeType(c, result, expectedType, check=true)
       else:
-        result.typ() = getSysType(c.graph, n.info, tyFloat64)
+        result.typ = getSysType(c.graph, n.info, tyFloat64)
   of nkFloat32Lit: directLiteral(tyFloat32)
   of nkFloat64Lit: directLiteral(tyFloat64)
   of nkFloat128Lit: directLiteral(tyFloat128)
@@ -3375,9 +3357,9 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType
       if expectedType != nil and (
           let expected = expectedType.skipTypes(abstractRange-{tyDistinct});
           expected.kind in {tyString, tyCstring}):
-        result.typ() = expectedType
+        result.typ = expectedType
       else:
-        result.typ() = getSysType(c.graph, n.info, tyString)
+        result.typ = getSysType(c.graph, n.info, tyString)
   of nkCharLit: directLiteral(tyChar)
   of nkDotExpr:
     result = semFieldAccess(c, n, flags)
@@ -3392,13 +3374,13 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType
       let modifier = n.modifierTypeKindOfNode
       if modifier != tyNone:
         var baseType = semExpr(c, n[0]).typ.skipTypes({tyTypeDesc})
-        result.typ() = c.makeTypeDesc(newTypeS(modifier, c, baseType))
+        result.typ = c.makeTypeDesc(newTypeS(modifier, c, baseType))
         return
     var typ = semTypeNode(c, n, nil).skipTypes({tyTypeDesc})
-    result.typ() = makeTypeDesc(c, typ)
+    result.typ = makeTypeDesc(c, typ)
   of nkStmtListType:
     let typ = semTypeNode(c, n, nil)
-    result.typ() = makeTypeDesc(c, typ)
+    result.typ = makeTypeDesc(c, typ)
   of nkCall, nkInfix, nkPrefix, nkPostfix, nkCommand, nkCallStrLit:
     # check if it is an expression macro:
     checkMinSonsLen(n, 1, c.config)

compiler/semfields.nim

@@ -18,15 +18,6 @@ type
     replaceByFieldName: bool
     c: PContext
 
-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 =
   if c.field != nil and isEmptyType(c.field.typ):
     result = newNode(nkEmpty)
@@ -81,9 +72,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)
@@ -159,8 +148,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

@@ -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
@@ -302,9 +302,6 @@ proc evalOp(m: TMagic, n, a, b, c: PNode; idgen: IdGenerator; g: ModuleGraph): P
   of mMinusSet:
     result = nimsets.diffSets(g.config, a, b)
     result.info = n.info
-  of mXorSet:
-    result = nimsets.symdiffSets(g.config, a, b)
-    result.info = n.info
   of mConStrStr: result = newStrNodeT(getStrOrChar(a) & getStrOrChar(b), n, g)
   of mInSet: result = newIntNodeT(toInt128(ord(inSet(a, b))), n, idgen, g)
   of mRepr:
@@ -319,7 +316,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 +411,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 +428,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 +438,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:
@@ -517,10 +514,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
@@ -639,7 +636,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:
@@ -752,7 +749,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:
@@ -763,7 +760,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
@@ -780,7 +777,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:

compiler/semgnrc.nim

@@ -78,10 +78,10 @@ proc semGenericStmtSymbol(c: PContext, n: PNode, s: PSym,
           if result.kind == nkSym:
             result = newOpenSym(result)
           else:
-            result.typ() = nil
+            result.typ = nil
         else:
           result.flags.incl nfDisabledOpenSym
-          result.typ() = nil
+          result.typ = nil
   case s.kind
   of skUnknown:
     # Introduced in this pass! Leave it as an identifier.
@@ -116,7 +116,7 @@ proc semGenericStmtSymbol(c: PContext, n: PNode, s: PSym,
             result = newOpenSym(result)
           else:
             result.flags.incl nfDisabledOpenSym
-            result.typ() = nil
+            result.typ = nil
       else:
         result = n
     else:
@@ -126,7 +126,7 @@ proc semGenericStmtSymbol(c: PContext, n: PNode, s: PSym,
           result = newOpenSym(result)
         else:
           result.flags.incl nfDisabledOpenSym
-          result.typ() = nil
+          result.typ = nil
     onUse(n.info, s)
   of skParam:
     result = n
@@ -145,7 +145,7 @@ proc semGenericStmtSymbol(c: PContext, n: PNode, s: PSym,
           result = newOpenSym(result)
         else:
           result.flags.incl nfDisabledOpenSym
-          result.typ() = nil
+          result.typ = nil
     elif c.inGenericContext > 0 and withinConcept notin flags:
       # don't leave generic param as identifier node in generic type,
       # sigmatch will try to instantiate generic type AST without all params
@@ -157,7 +157,7 @@ proc semGenericStmtSymbol(c: PContext, n: PNode, s: PSym,
           result = newOpenSym(result)
         else:
           result.flags.incl nfDisabledOpenSym
-          result.typ() = nil
+          result.typ = nil
     else:
       result = n
     onUse(n.info, s)
@@ -168,7 +168,7 @@ proc semGenericStmtSymbol(c: PContext, n: PNode, s: PSym,
         result = newOpenSym(result)
       else:
         result.flags.incl nfDisabledOpenSym
-        result.typ() = nil
+        result.typ = nil
     onUse(n.info, s)
 
 proc lookup(c: PContext, n: PNode, flags: TSemGenericFlags,
@@ -616,24 +616,7 @@ proc semGenericStmt(c: PContext, n: PNode,
     let bodyFlags = if n.kind == nkTemplateDef: flags + {withinMixin} else: flags
     n[bodyPos] = semGenericStmtScope(c, body, bodyFlags, ctx)
     closeScope(c)
-  of nkPragmaExpr:
-    result[1] = semGenericStmt(c, n[1], flags, ctx)
-  of nkPragma:
-    for i in 0 ..< n.len:
-      let x = n[i]
-      let prag = whichPragma(x)
-      if x.kind in nkPragmaCallKinds:
-        # process each child individually to prevent untyped macros/templates
-        # from instantiating
-        # if pragma is language-level pragma, skip name node:
-        let start = ord(prag != wInvalid)
-        for j in start ..< x.len:
-          # treat as mixin context for user pragmas & macro args
-          x[j] = semGenericStmt(c, x[j], flags+{withinMixin}, ctx)
-      elif prag == wInvalid:
-        # only sem if not a language-level pragma 
-        # treat as mixin context for user pragmas & macro args
-        result[i] = semGenericStmt(c, x, flags+{withinMixin}, ctx)
+  of nkPragma, nkPragmaExpr: discard
   of nkExprColonExpr, nkExprEqExpr:
     checkMinSonsLen(n, 2, c.config)
     result[1] = semGenericStmt(c, n[1], flags, ctx)

compiler/seminst.nim

@@ -34,7 +34,7 @@ proc pushProcCon*(c: PContext; owner: PSym) =
 const
   errCannotInstantiateX = "cannot instantiate: '$1'"
 
-iterator instantiateGenericParamList(c: PContext, n: PNode, pt: LayeredIdTable): PSym =
+iterator instantiateGenericParamList(c: PContext, n: PNode, pt: TypeMapping): PSym =
   internalAssert c.config, n.kind == nkGenericParams
   for a in n.items:
     internalAssert c.config, a.kind == nkSym
@@ -43,7 +43,7 @@ iterator instantiateGenericParamList(c: PContext, n: PNode, pt: LayeredIdTable):
       let symKind = if q.typ.kind == tyStatic: skConst else: skType
       var s = newSym(symKind, q.name, c.idgen, getCurrOwner(c), q.info)
       s.flags.incl {sfUsed, sfFromGeneric}
-      var t = lookup(pt, q.typ)
+      var t = idTableGet(pt, q.typ)
       if t == nil:
         if tfRetType in q.typ.flags:
           # keep the generic type and allow the return type to be bound
@@ -53,9 +53,7 @@ iterator instantiateGenericParamList(c: PContext, n: PNode, pt: LayeredIdTable):
           if q.typ.kind != tyCompositeTypeClass:
             localError(c.config, a.info, errCannotInstantiateX % s.name.s)
           t = errorType(c)
-      elif t.kind in {tyGenericParam, tyConcept, tyFromExpr} or
-          # generic body types are accepted as typedesc arguments
-          (t.kind == tyGenericBody and q.typ.kind != tyTypeDesc):
+      elif t.kind in {tyGenericParam, tyConcept, tyFromExpr}:
         localError(c.config, a.info, errCannotInstantiateX % q.name.s)
         t = errorType(c)
       elif isUnresolvedStatic(t) and (q.typ.kind == tyStatic or
@@ -111,7 +109,7 @@ proc freshGenSyms(c: PContext; n: PNode, owner, orig: PSym, symMap: var SymMappi
     elif s.owner == nil or s.owner.kind == skPackage:
       #echo "copied this ", s.name.s
       x = copySym(s, c.idgen)
-      setOwner(x, owner)
+      x.owner = owner
       idTablePut(symMap, s, x)
       n.sym = x
   else:
@@ -222,7 +220,7 @@ proc referencesAnotherParam(n: PNode, p: PSym): bool =
       if referencesAnotherParam(n[i], p): return true
     return false
 
-proc instantiateProcType(c: PContext, pt: LayeredIdTable,
+proc instantiateProcType(c: PContext, pt: TypeMapping,
                          prc: PSym, info: TLineInfo) =
   # XXX: Instantiates a generic proc signature, while at the same
   # time adding the instantiated proc params into the current scope.
@@ -239,7 +237,7 @@ proc instantiateProcType(c: PContext, pt: LayeredIdTable,
   # will need to use openScope, addDecl, etc.
   #addDecl(c, prc)
   pushInfoContext(c.config, info)
-  var typeMap = shallowCopy(pt) # use previous bindings without writing to them
+  var typeMap = initLayeredTypeMap(pt)
   var cl = initTypeVars(c, typeMap, info, nil)
   var result = instCopyType(cl, prc.typ)
   let originalParams = result.n
@@ -273,7 +271,7 @@ proc instantiateProcType(c: PContext, pt: LayeredIdTable,
     internalAssert c.config, originalParams[i].kind == nkSym
     let oldParam = originalParams[i].sym
     let param = copySym(oldParam, c.idgen)
-    setOwner(param, prc)
+    param.owner = prc
     param.typ = result[i]
 
     # The default value is instantiated and fitted against the final
@@ -302,7 +300,7 @@ proc instantiateProcType(c: PContext, pt: LayeredIdTable,
         # the only way the default value might be inserted).
         param.ast = errorNode(c, def)
         # we know the node is empty, we need the actual type for error message
-        param.ast.typ() = def.typ
+        param.ast.typ = def.typ
       else:
         param.ast = fitNodePostMatch(c, typeToFit, converted)
       param.typ = result[i]
@@ -326,7 +324,7 @@ proc instantiateProcType(c: PContext, pt: LayeredIdTable,
   prc.typ = result
   popInfoContext(c.config)
 
-proc instantiateOnlyProcType(c: PContext, pt: LayeredIdTable, prc: PSym, info: TLineInfo): PType =
+proc instantiateOnlyProcType(c: PContext, pt: TypeMapping, prc: PSym, info: TLineInfo): PType =
   # instantiates only the type of a given proc symbol
   # used by sigmatch for explicit generics
   # wouldn't be needed if sigmatch could handle complex cases,
@@ -362,7 +360,7 @@ proc getLocalPassC(c: PContext, s: PSym): string =
     for p in n:
       extractPassc(p)
 
-proc generateInstance(c: PContext, fn: PSym, pt: LayeredIdTable,
+proc generateInstance(c: PContext, fn: PSym, pt: TypeMapping,
                       info: TLineInfo): PSym =
   ## Generates a new instance of a generic procedure.
   ## The `pt` parameter is a type-unsafe mapping table used to link generic
@@ -373,11 +371,7 @@ proc generateInstance(c: PContext, fn: PSym, pt: LayeredIdTable,
   if c.instCounter > 50:
     globalError(c.config, info, "generic instantiation too nested")
   inc c.instCounter
-  let currentTypeofContext = c.inTypeofContext
-  c.inTypeofContext = 0
-  defer:
-    dec c.instCounter
-    c.inTypeofContext = currentTypeofContext
+  defer: dec c.instCounter
   # careful! we copy the whole AST including the possibly nil body!
   var n = copyTree(fn.ast)
   # NOTE: for access of private fields within generics from a different module
@@ -395,9 +389,9 @@ proc generateInstance(c: PContext, fn: PSym, pt: LayeredIdTable,
     let passc = getLocalPassC(c, producer)
     if passc != "": #pass the local compiler options to the consumer module too
       extccomp.addLocalCompileOption(c.config, passc, toFullPathConsiderDirty(c.config, c.module.info.fileIndex))
-    setOwner(result, c.module)
+    result.owner = c.module
   else:
-    setOwner(result, fn)
+    result.owner = fn
   result.ast = n
   pushOwner(c, result)
 

compiler/semmacrosanity.nim

@@ -50,8 +50,8 @@ proc annotateType*(n: PNode, t: PType; conf: ConfigRef) =
   case n.kind
   of nkObjConstr:
     let x = t.skipTypes(abstractPtrs)
-    n.typ() = t
-    n[0].typ() = t
+    n.typ = t
+    n[0].typ = t
     for i in 1..<n.len:
       var j = i-1
       let field = x.ithField(j)
@@ -62,12 +62,12 @@ proc annotateType*(n: PNode, t: PType; conf: ConfigRef) =
         annotateType(n[i][1], field.typ, conf)
   of nkPar, nkTupleConstr:
     if x.kind == tyTuple:
-      n.typ() = t
+      n.typ = t
       for i in 0..<n.len:
         if i >= x.kidsLen: globalError conf, n.info, "invalid field at index " & $i
         else: annotateType(n[i], x[i], conf)
     elif x.kind == tyProc and x.callConv == ccClosure:
-      n.typ() = t
+      n.typ = t
     elif x.kind == tyOpenArray: # `opcSlice` transforms slices into tuples
       if n.kind == nkTupleConstr:
         let
@@ -88,39 +88,39 @@ proc annotateType*(n: PNode, t: PType; conf: ConfigRef) =
           globalError(conf, n.info, "Incorrectly generated tuple constr")
         n[] = bracketExpr[]
 
-      n.typ() = t
+      n.typ = t
     else:
       globalError(conf, n.info, "() must have a tuple type")
   of nkBracket:
     if x.kind in {tyArray, tySequence, tyOpenArray}:
-      n.typ() = t
+      n.typ = t
       for m in n: annotateType(m, x.elemType, conf)
     else:
       globalError(conf, n.info, "[] must have some form of array type")
   of nkCurly:
     if x.kind in {tySet}:
-      n.typ() = t
+      n.typ = t
       for m in n: annotateType(m, x.elemType, conf)
     else:
       globalError(conf, n.info, "{} must have the set type")
   of nkFloatLit..nkFloat128Lit:
     if x.kind in {tyFloat..tyFloat128}:
-      n.typ() = t
+      n.typ = t
     else:
       globalError(conf, n.info, "float literal must have some float type")
   of nkCharLit..nkUInt64Lit:
     if x.kind in {tyInt..tyUInt64, tyBool, tyChar, tyEnum}:
-      n.typ() = t
+      n.typ = t
     else:
       globalError(conf, n.info, "integer literal must have some int type")
   of nkStrLit..nkTripleStrLit:
     if x.kind in {tyString, tyCstring}:
-      n.typ() = t
+      n.typ = t
     else:
       globalError(conf, n.info, "string literal must be of some string type")
   of nkNilLit:
     if x.kind in NilableTypes+{tyString, tySequence}:
-      n.typ() = t
+      n.typ = t
     else:
       globalError(conf, n.info, "nil literal must be of some pointer type")
   else: discard

compiler/semmagic.nim

@@ -18,7 +18,7 @@ proc addDefaultFieldForNew(c: PContext, n: PNode): PNode =
   let typ = result[1].typ # new(x)
   if typ.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyRef and typ.skipTypes({tyGenericInst, tyAlias, tySink})[0].kind == tyObject:
     var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, result[1].info, typ))
-    asgnExpr.typ() = typ
+    asgnExpr.typ = typ
     var t = typ.skipTypes({tyGenericInst, tyAlias, tySink})[0]
     while true:
       asgnExpr.sons.add defaultFieldsForTheUninitialized(c, t.n, false)
@@ -38,7 +38,7 @@ proc semAddr(c: PContext; n: PNode): PNode =
   if isAssignable(c, x) notin {arLValue, arLocalLValue, arAddressableConst, arLentValue}:
     localError(c.config, n.info, errExprHasNoAddress)
   result.add x
-  result.typ() = makePtrType(c, x.typ)
+  result.typ = makePtrType(c, x.typ)
 
 proc semTypeOf(c: PContext; n: PNode): PNode =
   var m = BiggestInt 1 # typeOfIter
@@ -55,18 +55,18 @@ proc semTypeOf(c: PContext; n: PNode): PNode =
   result.add typExpr
   if typExpr.typ.kind == tyFromExpr:
     typExpr.typ.flags.incl tfNonConstExpr
-  result.typ() = makeTypeDesc(c, typExpr.typ)
+  result.typ = makeTypeDesc(c, typExpr.typ)
 
 type
   SemAsgnMode = enum asgnNormal, noOverloadedSubscript, noOverloadedAsgn
 
 proc semAsgn(c: PContext, n: PNode; mode=asgnNormal): PNode
-proc semSubscript(c: PContext, n: PNode, flags: TExprFlags, afterOverloading = false): PNode
+proc semSubscript(c: PContext, n: PNode, flags: TExprFlags): PNode
 
 proc semArrGet(c: PContext; n: PNode; flags: TExprFlags): PNode =
   result = newNodeI(nkBracketExpr, n.info)
   for i in 1..<n.len: result.add(n[i])
-  result = semSubscript(c, result, flags, afterOverloading = true)
+  result = semSubscript(c, result, flags)
   if result.isNil:
     let x = copyTree(n)
     x[0] = newIdentNode(getIdent(c.cache, "[]"), n.info)
@@ -76,23 +76,12 @@ proc semArrGet(c: PContext; n: PNode; flags: TExprFlags): PNode =
         if a.typ != nil and a.typ.kind in {tyGenericParam, tyFromExpr}:
           # expression is compiled early in a generic body
           result = semGenericStmt(c, x)
-          result.typ() = makeTypeFromExpr(c, copyTree(result))
+          result.typ = makeTypeFromExpr(c, copyTree(result))
           result.typ.flags.incl tfNonConstExpr
           return
-    let s = # extract sym from first arg
-      if n.len > 1:
-        if n[1].kind == nkSym: n[1].sym
-        elif n[1].kind in nkSymChoices + {nkOpenSym} and n[1].len != 0:
-          n[1][0].sym
-        else: nil
-      else: nil
-    if s != nil and s.kind in routineKinds:
-      # this is a failed generic instantiation
-      # semSubscript should already error but this is better for cascading errors
-      result = explicitGenericInstError(c, n)
-    else:
-      bracketNotFoundError(c, x, flags)
-      result = errorNode(c, n)
+    bracketNotFoundError(c, x, flags)
+    #localError(c.config, n.info, "could not resolve: " & $n)
+    result = errorNode(c, n)
 
 proc semArrPut(c: PContext; n: PNode; flags: TExprFlags): PNode =
   # rewrite `[]=`(a, i, x)  back to ``a[i] = x``.
@@ -200,15 +189,15 @@ proc evalTypeTrait(c: PContext; traitCall: PNode, operand: PType, context: PSym)
       let preferStr = traitCall[2].strVal
       prefer = parseEnum[TPreferedDesc](preferStr)
     result = newStrNode(nkStrLit, operand.typeToString(prefer))
-    result.typ() = getSysType(c.graph, traitCall[1].info, tyString)
+    result.typ = getSysType(c.graph, traitCall[1].info, tyString)
     result.info = traitCall.info
   of "name", "$":
     result = newStrNode(nkStrLit, operand.typeToString(preferTypeName))
-    result.typ() = getSysType(c.graph, traitCall[1].info, tyString)
+    result.typ = getSysType(c.graph, traitCall[1].info, tyString)
     result.info = traitCall.info
   of "arity":
     result = newIntNode(nkIntLit, operand.len - ord(operand.kind==tyProc))
-    result.typ() = newType(tyInt, c.idgen, context)
+    result.typ = newType(tyInt, c.idgen, context)
     result.info = traitCall.info
   of "genericHead":
     var arg = operand
@@ -278,7 +267,7 @@ proc semOrd(c: PContext, n: PNode): PNode =
     discard
   else:
     localError(c.config, n.info, errOrdinalTypeExpected % typeToString(parType, preferDesc))
-    result.typ() = errorType(c)
+    result.typ = errorType(c)
 
 proc semBindSym(c: PContext, n: PNode): PNode =
   result = copyNode(n)
@@ -394,7 +383,7 @@ proc semOf(c: PContext, n: PNode): PNode =
         message(c.config, n.info, hintConditionAlwaysTrue, renderTree(n))
         result = newIntNode(nkIntLit, 1)
         result.info = n.info
-        result.typ() = getSysType(c.graph, n.info, tyBool)
+        result.typ = getSysType(c.graph, n.info, tyBool)
         return result
       elif diff == high(int):
         if commonSuperclass(a, b) == nil:
@@ -403,10 +392,10 @@ proc semOf(c: PContext, n: PNode): PNode =
           message(c.config, n.info, hintConditionAlwaysFalse, renderTree(n))
           result = newIntNode(nkIntLit, 0)
           result.info = n.info
-          result.typ() = getSysType(c.graph, n.info, tyBool)
+          result.typ = getSysType(c.graph, n.info, tyBool)
   else:
     localError(c.config, n.info, "'of' takes 2 arguments")
-  n.typ() = getSysType(c.graph, n.info, tyBool)
+  n.typ = getSysType(c.graph, n.info, tyBool)
   result = n
 
 proc semUnown(c: PContext; n: PNode): PNode =
@@ -441,9 +430,9 @@ proc semUnown(c: PContext; n: PNode): PNode =
       result = t
 
   result = copyTree(n[1])
-  result.typ() = unownedType(c, result.typ)
+  result.typ = unownedType(c, result.typ)
   # little hack for injectdestructors.nim (see bug #11350):
-  #result[0].typ() = nil
+  #result[0].typ = nil
 
 proc turnFinalizerIntoDestructor(c: PContext; orig: PSym; info: TLineInfo): PSym =
   # We need to do 2 things: Replace n.typ which is a 'ref T' by a 'var T' type.
@@ -453,7 +442,7 @@ proc turnFinalizerIntoDestructor(c: PContext; orig: PSym; info: TLineInfo): PSym
   proc transform(c: PContext; n: PNode; old, fresh: PType; oldParam, newParam: PSym): PNode =
     result = shallowCopy(n)
     if sameTypeOrNil(n.typ, old):
-      result.typ() = fresh
+      result.typ = fresh
     if n.kind == nkSym and n.sym == oldParam:
       result.sym = newParam
     for i in 0 ..< safeLen(n):
@@ -464,7 +453,7 @@ proc turnFinalizerIntoDestructor(c: PContext; orig: PSym; info: TLineInfo): PSym
   result = copySym(orig, c.idgen)
   result.info = info
   result.flags.incl sfFromGeneric
-  setOwner(result, orig)
+  result.owner = orig
   let origParamType = orig.typ.firstParamType
   let newParamType = makeVarType(result, origParamType.skipTypes(abstractPtrs), c.idgen)
   let oldParam = orig.typ.n[1].sym
@@ -535,34 +524,32 @@ proc semNewFinalize(c: PContext; n: PNode): PNode =
         discard "already turned this one into a finalizer"
       else:
         if fin.instantiatedFrom != nil and fin.instantiatedFrom != fin.owner: #undo move
-          setOwner(fin, fin.instantiatedFrom)
+          fin.owner = fin.instantiatedFrom
+        let wrapperSym = newSym(skProc, getIdent(c.graph.cache, fin.name.s & "FinalizerWrapper"), c.idgen, fin.owner, fin.info)
+        let selfSymNode = newSymNode(copySym(fin.ast[paramsPos][1][0].sym, c.idgen))
+        selfSymNode.typ = fin.typ.firstParamType
+        wrapperSym.flags.incl sfUsed
 
-        if fin.typ[1].skipTypes(abstractInst).kind != tyRef:
-          bindTypeHook(c, fin, n, attachedDestructor)
-        else:
-          let wrapperSym = newSym(skProc, getIdent(c.graph.cache, fin.name.s & "FinalizerWrapper"), c.idgen, fin.owner, fin.info)
-          let selfSymNode = newSymNode(copySym(fin.ast[paramsPos][1][0].sym, c.idgen))
-          selfSymNode.typ() = fin.typ.firstParamType
-          wrapperSym.flags.incl sfUsed
+        let wrapper = c.semExpr(c, newProcNode(nkProcDef, fin.info, body = newTree(nkCall, newSymNode(fin), selfSymNode),
+          params = nkFormalParams.newTree(c.graph.emptyNode,
+                  newTree(nkIdentDefs, selfSymNode, newNodeIT(nkType,
+                  fin.ast[paramsPos][1][1].info, fin.typ.firstParamType), c.graph.emptyNode)
+                  ),
+          name = newSymNode(wrapperSym), pattern = fin.ast[patternPos],
+          genericParams = fin.ast[genericParamsPos], pragmas = fin.ast[pragmasPos], exceptions = fin.ast[miscPos]), {})
 
-          let wrapper = c.semExpr(c, newProcNode(nkProcDef, fin.info, body = newTree(nkCall, newSymNode(fin), selfSymNode),
-            params = nkFormalParams.newTree(c.graph.emptyNode,
-                    newTree(nkIdentDefs, selfSymNode, newNodeIT(nkType,
-                    fin.ast[paramsPos][1][1].info, fin.typ.firstParamType), c.graph.emptyNode)
-                    ),
-            name = newSymNode(wrapperSym), pattern = fin.ast[patternPos],
-            genericParams = fin.ast[genericParamsPos], pragmas = fin.ast[pragmasPos], exceptions = fin.ast[miscPos]), {})
-
-          var transFormedSym = turnFinalizerIntoDestructor(c, wrapperSym, wrapper.info)
-          setOwner(transFormedSym, fin)
-          if c.config.backend == backendCpp or sfCompileToCpp in c.module.flags:
-            let origParamType = transFormedSym.ast[bodyPos][1].typ
-            let selfSymbolType = makePtrType(c, origParamType.skipTypes(abstractPtrs))
-            let selfPtr = newNodeI(nkHiddenAddr, transFormedSym.ast[bodyPos][1].info)
-            selfPtr.add transFormedSym.ast[bodyPos][1]
-            selfPtr.typ() = selfSymbolType
-            transFormedSym.ast[bodyPos][1] = c.semExpr(c, selfPtr)
-          bindTypeHook(c, transFormedSym, n, attachedDestructor)
+        var transFormedSym = turnFinalizerIntoDestructor(c, wrapperSym, wrapper.info)
+        transFormedSym.owner = fin
+        if c.config.backend == backendCpp or sfCompileToCpp in c.module.flags:
+          let origParamType = transFormedSym.ast[bodyPos][1].typ
+          let selfSymbolType = makePtrType(c, origParamType.skipTypes(abstractPtrs))
+          let selfPtr = newNodeI(nkHiddenAddr, transFormedSym.ast[bodyPos][1].info)
+          selfPtr.add transFormedSym.ast[bodyPos][1]
+          selfPtr.typ = selfSymbolType
+          transFormedSym.ast[bodyPos][1] = c.semExpr(c, selfPtr)
+        # TODO: suppress var destructor warnings; if newFinalizer is not
+        # TODO: deprecated, try to implement plain T destructor
+        bindTypeHook(c, transFormedSym, n, attachedDestructor, suppressVarDestructorWarning = true)
   result = addDefaultFieldForNew(c, n)
 
 proc semPrivateAccess(c: PContext, n: PNode): PNode =
@@ -614,7 +601,7 @@ proc magicsAfterOverloadResolution(c: PContext, n: PNode,
   of mTypeTrait: result = semTypeTraits(c, n)
   of mAstToStr:
     result = newStrNodeT(renderTree(n[1], {renderNoComments}), n, c.graph)
-    result.typ() = getSysType(c.graph, n.info, tyString)
+    result.typ = getSysType(c.graph, n.info, tyString)
   of mInstantiationInfo: result = semInstantiationInfo(c, n)
   of mOrd: result = semOrd(c, n)
   of mOf: result = semOf(c, n)
@@ -627,7 +614,7 @@ proc magicsAfterOverloadResolution(c: PContext, n: PNode,
       result = semDynamicBindSym(c, n)
   of mProcCall:
     result = n
-    result.typ() = n[1].typ
+    result.typ = n[1].typ
   of mDotDot:
     result = n
   of mPlugin:
@@ -670,7 +657,7 @@ proc magicsAfterOverloadResolution(c: PContext, n: PNode,
       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)
+        boolLit.typ = getSysType(c.graph, n.info, tyBool)
         result.add boolLit
   of mWasMoved:
     result = n
@@ -712,7 +699,7 @@ proc magicsAfterOverloadResolution(c: PContext, n: PNode,
     result = n
     if result.typ != nil and expectedType != nil and result.typ.kind == tySequence and
         expectedType.kind == tySequence and result.typ.elementType.kind == tyEmpty:
-      result.typ() = expectedType # type inference for empty sequence # bug #21377
+      result.typ = expectedType # type inference for empty sequence # bug #21377
   of mEnsureMove:
     result = n
     if n[1].kind in {nkStmtListExpr, nkBlockExpr,

compiler/semobjconstr.nim

@@ -188,7 +188,7 @@ proc collectOrAddMissingCaseFields(c: PContext, branchNode: PNode,
           newNodeIT(nkType, constrCtx.initExpr.info, asgnType)
         )
     asgnExpr.flags.incl nfSkipFieldChecking
-    asgnExpr.typ() = recTyp
+    asgnExpr.typ = recTyp
     defaults.add newTree(nkExprColonExpr, newSymNode(sym), asgnExpr)
 
 proc collectBranchFields(c: PContext, n: PNode, discriminatorVal: PNode,
@@ -475,7 +475,7 @@ proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType
   if t.kind == tyRef:
     t = skipTypes(t.elementType, {tyGenericInst, tyAlias, tySink, tyOwned})
     if optOwnedRefs in c.config.globalOptions:
-      result.typ() = makeVarType(c, result.typ, tyOwned)
+      result.typ = makeVarType(c, result.typ, tyOwned)
       # we have to watch out, there are also 'owned proc' types that can be used
       # multiple times as long as they don't have closures.
       result.typ.flags.incl tfHasOwned

compiler/semparallel.nim

@@ -407,9 +407,9 @@ proc transformSlices(g: ModuleGraph; idgen: IdGenerator; n: PNode): PNode =
       result = copyNode(n)
       var typ = newType(tyOpenArray, idgen, result.typ.owner)
       typ.add result.typ.elementType
-      result.typ() = typ
+      result.typ = typ
       let opSlice = newSymNode(createMagic(g, idgen, "slice", mSlice))
-      opSlice.typ() = getSysType(g, n.info, tyInt)
+      opSlice.typ = getSysType(g, n.info, tyInt)
       result.add opSlice
       result.add n[1]
       let slice = n[2].skipStmtList

compiler/sempass2.nim

@@ -193,7 +193,7 @@ proc guardDotAccess(a: PEffects; n: PNode) =
     let dot = newNodeI(nkDotExpr, n.info, 2)
     dot[0] = n[0]
     dot[1] = newSymNode(g)
-    dot.typ() = g.typ
+    dot.typ = g.typ
     for L in a.locked:
       #if a.guards.sameSubexprs(dot, L): return
       if guards.sameTree(dot, L): return
@@ -411,7 +411,7 @@ proc throws(tracked, n, orig: PNode) =
   if n.typ == nil or n.typ.kind != tyError:
     if orig != nil:
       let x = copyTree(orig)
-      x.typ() = n.typ
+      x.typ = n.typ
       tracked.add x
     else:
       tracked.add n
@@ -426,12 +426,12 @@ proc excType(g: ModuleGraph; n: PNode): PType =
 
 proc createRaise(g: ModuleGraph; n: PNode): PNode =
   result = newNode(nkType)
-  result.typ() = getEbase(g, n.info)
+  result.typ = getEbase(g, n.info)
   if not n.isNil: result.info = n.info
 
 proc createTag(g: ModuleGraph; n: PNode): PNode =
   result = newNode(nkType)
-  result.typ() = g.sysTypeFromName(n.info, "RootEffect")
+  result.typ = g.sysTypeFromName(n.info, "RootEffect")
   if not n.isNil: result.info = n.info
 
 proc addRaiseEffect(a: PEffects, e, comesFrom: PNode) =
@@ -1210,7 +1210,7 @@ proc track(tracked: PEffects, n: PNode) =
     if n.sym.typ != nil and tfHasAsgn in n.sym.typ.flags:
       tracked.owner.flags.incl sfInjectDestructors
       # bug #15038: ensure consistency
-      if n.typ == nil or (not hasDestructor(n.typ) and sameType(n.typ, n.sym.typ)): n.typ() = n.sym.typ
+      if n.typ == nil or (not hasDestructor(n.typ) and sameType(n.typ, n.sym.typ)): n.typ = n.sym.typ
   of nkHiddenAddr, nkAddr:
     if n[0].kind == nkSym and isLocalSym(tracked, n[0].sym) and
           n.typ.kind notin {tyVar, tyLent}:

compiler/semstmts.nim

@@ -112,11 +112,11 @@ proc semWhile(c: PContext, n: PNode; flags: TExprFlags): PNode =
   dec(c.p.nestedLoopCounter)
   closeScope(c)
   if n[1].typ == c.enforceVoidContext:
-    result.typ() = c.enforceVoidContext
+    result.typ = c.enforceVoidContext
   elif efInTypeof in flags:
-    result.typ() = n[1].typ
+    result.typ = n[1].typ
   elif implicitlyDiscardable(n[1]):
-    result[1].typ() = c.enforceVoidContext
+    result[1].typ = c.enforceVoidContext
 
 proc semProc(c: PContext, n: PNode): PNode
 
@@ -275,7 +275,7 @@ proc fixNilType(c: PContext; n: PNode) =
   elif n.kind in {nkStmtList, nkStmtListExpr}:
     n.transitionSonsKind(nkStmtList)
     for it in n: fixNilType(c, it)
-  n.typ() = nil
+  n.typ = nil
 
 proc discardCheck(c: PContext, result: PNode, flags: TExprFlags) =
   if c.matchedConcept != nil or efInTypeof in flags: return
@@ -331,14 +331,14 @@ proc semIf(c: PContext, n: PNode; flags: TExprFlags; expectedType: PType = nil):
     for it in n: discardCheck(c, it.lastSon, flags)
     result.transitionSonsKind(nkIfStmt)
     # propagate any enforced VoidContext:
-    if typ == c.enforceVoidContext: result.typ() = c.enforceVoidContext
+    if typ == c.enforceVoidContext: result.typ = c.enforceVoidContext
   else:
     for it in n:
       let j = it.len-1
       if not endsInNoReturn(it[j]):
         it[j] = fitNode(c, typ, it[j], it[j].info)
     result.transitionSonsKind(nkIfExpr)
-    result.typ() = typ
+    result.typ = typ
 
 proc semTry(c: PContext, n: PNode; flags: TExprFlags; expectedType: PType = nil): PNode =
   var check = initIntSet()
@@ -438,7 +438,7 @@ proc semTry(c: PContext, n: PNode; flags: TExprFlags; expectedType: PType = nil)
     discardCheck(c, n[0], flags)
     for i in 1..<n.len: discardCheck(c, n[i].lastSon, flags)
     if typ == c.enforceVoidContext:
-      result.typ() = c.enforceVoidContext
+      result.typ = c.enforceVoidContext
   else:
     if n.lastSon.kind == nkFinally: discardCheck(c, n.lastSon.lastSon, flags)
     if not endsInNoReturn(n[0]):
@@ -448,7 +448,7 @@ proc semTry(c: PContext, n: PNode; flags: TExprFlags; expectedType: PType = nil)
       let j = it.len-1
       if not endsInNoReturn(it[j]):
         it[j] = fitNode(c, typ, it[j], it[j].info)
-    result.typ() = typ
+    result.typ = typ
 
 proc fitRemoveHiddenConv(c: PContext, typ: PType, n: PNode): PNode =
   result = fitNode(c, typ, n, n.info)
@@ -457,7 +457,7 @@ proc fitRemoveHiddenConv(c: PContext, typ: PType, n: PNode): PNode =
     if r1.kind in {nkCharLit..nkUInt64Lit} and typ.skipTypes(abstractRange).kind in {tyFloat..tyFloat128}:
       result = newFloatNode(nkFloatLit, BiggestFloat r1.intVal)
       result.info = n.info
-      result.typ() = typ
+      result.typ = typ
       if not floatRangeCheck(result.floatVal, typ):
         localError(c.config, n.info, errFloatToString % [$result.floatVal, typeToString(typ)])
     elif r1.kind == nkSym and typ.skipTypes(abstractRange).kind == tyCstring:
@@ -605,7 +605,7 @@ proc fillPartialObject(c: PContext; n: PNode; typ: PType) =
       obj.n.add newSymNode(field)
       n[0] = makeDeref x
       n[1] = newSymNode(field)
-      n.typ() = field.typ
+      n.typ = field.typ
     else:
       localError(c.config, n.info, "implicit object field construction " &
         "requires a .partial object, but got " & typeToString(obj))
@@ -908,7 +908,7 @@ proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode =
         if sfGenSym notin v.flags:
           if not isDiscardUnderscore(v): addInterfaceDecl(c, v)
         else:
-          if v.owner == nil: setOwner(v, c.p.owner)
+          if v.owner == nil: v.owner = c.p.owner
         when oKeepVariableNames:
           if c.inUnrolledContext > 0: v.flags.incl(sfShadowed)
           else:
@@ -1026,7 +1026,7 @@ proc semConst(c: PContext, n: PNode): PNode =
         when defined(nimsuggest):
           v.hasUserSpecifiedType = hasUserSpecifiedType
         if sfGenSym notin v.flags: addInterfaceDecl(c, v)
-        elif v.owner == nil: setOwner(v, getCurrOwner(c))
+        elif v.owner == nil: v.owner = getCurrOwner(c)
         styleCheckDef(c, v)
         onDef(a[j].info, v)
 
@@ -1097,7 +1097,7 @@ proc semForVars(c: PContext, n: PNode; flags: TExprFlags): PNode =
             v.typ = iter[i]
           n[0][i] = newSymNode(v)
           if sfGenSym notin v.flags and not isDiscardUnderscore(v): addDecl(c, v)
-          elif v.owner == nil: setOwner(v, getCurrOwner(c))
+          elif v.owner == nil: v.owner = getCurrOwner(c)
       else:
         var v = symForVar(c, n[0])
         if getCurrOwner(c).kind == skModule: incl(v.flags, sfGlobal)
@@ -1107,7 +1107,7 @@ proc semForVars(c: PContext, n: PNode; flags: TExprFlags): PNode =
         v.typ = iterBase
         n[0] = newSymNode(v)
         if sfGenSym notin v.flags and not isDiscardUnderscore(v): addDecl(c, v)
-        elif v.owner == nil: setOwner(v, getCurrOwner(c))
+        elif v.owner == nil: v.owner = getCurrOwner(c)
     else:
       localError(c.config, n.info, errWrongNumberOfVariables)
   elif n.len-2 != iterAfterVarLent.len:
@@ -1141,7 +1141,7 @@ proc semForVars(c: PContext, n: PNode; flags: TExprFlags): PNode =
             v.typ = iter[i][j]
           n[i][j] = newSymNode(v)
           if not isDiscardUnderscore(v): addDecl(c, v)
-          elif v.owner == nil: setOwner(v, getCurrOwner(c))
+          elif v.owner == nil: v.owner = getCurrOwner(c)
       else:
         var v = symForVar(c, n[i])
         if getCurrOwner(c).kind == skModule: incl(v.flags, sfGlobal)
@@ -1156,7 +1156,7 @@ proc semForVars(c: PContext, n: PNode; flags: TExprFlags): PNode =
         n[i] = newSymNode(v)
         if sfGenSym notin v.flags:
           if not isDiscardUnderscore(v): addDecl(c, v)
-        elif v.owner == nil: setOwner(v, getCurrOwner(c))
+        elif v.owner == nil: v.owner = getCurrOwner(c)
   inc(c.p.nestedLoopCounter)
   let oldBreakInLoop = c.p.breakInLoop
   c.p.breakInLoop = true
@@ -1291,9 +1291,9 @@ proc semFor(c: PContext, n: PNode; flags: TExprFlags): PNode =
     result = semForVars(c, n, flags)
   # propagate any enforced VoidContext:
   if n[^1].typ == c.enforceVoidContext:
-    result.typ() = c.enforceVoidContext
+    result.typ = c.enforceVoidContext
   elif efInTypeof in flags:
-    result.typ() = result.lastSon.typ
+    result.typ = result.lastSon.typ
   closeScope(c)
 
 proc semCase(c: PContext, n: PNode; flags: TExprFlags; expectedType: PType = nil): PNode =
@@ -1373,14 +1373,14 @@ proc semCase(c: PContext, n: PNode; flags: TExprFlags; expectedType: PType = nil
     for i in 1..<n.len: discardCheck(c, n[i].lastSon, flags)
     # propagate any enforced VoidContext:
     if typ == c.enforceVoidContext:
-      result.typ() = c.enforceVoidContext
+      result.typ = c.enforceVoidContext
   else:
     for i in 1..<n.len:
       var it = n[i]
       let j = it.len-1
       if not endsInNoReturn(it[j]):
         it[j] = fitNode(c, typ, it[j], it[j].info)
-    result.typ() = typ
+    result.typ = typ
 
 proc semRaise(c: PContext, n: PNode): PNode =
   result = n
@@ -1475,7 +1475,7 @@ proc typeDefLeftSidePass(c: PContext, typeSection: PNode, i: int) =
           s = typsym
     # add it here, so that recursive types are possible:
     if sfGenSym notin s.flags: addInterfaceDecl(c, s)
-    elif s.owner == nil: setOwner(s, getCurrOwner(c))
+    elif s.owner == nil: s.owner = getCurrOwner(c)
 
   if name.kind == nkPragmaExpr:
     if name[0].kind == nkPostfix:
@@ -1969,13 +1969,13 @@ proc semProcAnnotation(c: PContext, prc: PNode;
 
       return result
 
-proc semInferredLambda(c: PContext, pt: LayeredIdTable, n: PNode): PNode =
+proc semInferredLambda(c: PContext, pt: TypeMapping, n: PNode): PNode =
   ## used for resolving 'auto' in lambdas based on their callsite
   var n = n
   let original = n[namePos].sym
   let s = original #copySym(original, false)
   #incl(s.flags, sfFromGeneric)
-  #s.owner() = original
+  #s.owner = original
 
   n = replaceTypesInBody(c, pt, n, original)
   result = n
@@ -1990,7 +1990,7 @@ proc semInferredLambda(c: PContext, pt: LayeredIdTable, n: PNode): PNode =
                               tyFromExpr}+tyTypeClasses:
       localError(c.config, params[i].info, "cannot infer type of parameter: " &
                  params[i].sym.name.s)
-    #params[i].sym.owner() = s
+    #params[i].sym.owner = s
   openScope(c)
   pushOwner(c, s)
   addParams(c, params, skProc)
@@ -2002,7 +2002,7 @@ proc semInferredLambda(c: PContext, pt: LayeredIdTable, n: PNode): PNode =
   popOwner(c)
   closeScope(c)
   if optOwnedRefs in c.config.globalOptions and result.typ != nil:
-    result.typ() = makeVarType(c, result.typ, tyOwned)
+    result.typ = makeVarType(c, result.typ, tyOwned)
   # alternative variant (not quite working):
   # var prc = arg[0].sym
   # let inferred = c.semGenerateInstance(c, prc, m.bindings, arg.info)
@@ -2092,7 +2092,7 @@ proc bindDupHook(c: PContext; s: PSym; n: PNode; op: TTypeAttachedOp) =
   incl(s.flags, sfUsed)
   incl(s.flags, sfOverridden)
 
-proc bindTypeHook(c: PContext; s: PSym; n: PNode; op: TTypeAttachedOp) =
+proc bindTypeHook(c: PContext; s: PSym; n: PNode; op: TTypeAttachedOp; suppressVarDestructorWarning = false) =
   let t = s.typ
   var noError = false
   let cond = case op
@@ -2116,7 +2116,7 @@ proc bindTypeHook(c: PContext; s: PSym; n: PNode; op: TTypeAttachedOp) =
       elif obj.kind == tyGenericInvocation: obj = obj.genericHead
       else: break
     if obj.kind in {tyObject, tyDistinct, tySequence, tyString}:
-      if op == attachedDestructor and t.firstParamType.kind == tyVar and
+      if (not suppressVarDestructorWarning) and op == attachedDestructor and t.firstParamType.kind == tyVar and
           c.config.selectedGC in {gcArc, gcAtomicArc, gcOrc}:
         message(c.config, n.info, warnDeprecated, "A custom '=destroy' hook which takes a 'var T' parameter is deprecated; it should take a 'T' parameter")
       obj = canonType(c, obj)
@@ -2362,7 +2362,7 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
     n[namePos] = newSymNode(s)
   of nkSym:
     s = n[namePos].sym
-    setOwner(s, c.getCurrOwner)
+    s.owner = c.getCurrOwner
   else:
     # Highlighting needs to be done early so the position for
     # name isn't changed (see taccent_highlight). We don't want to check if this is the
@@ -2608,9 +2608,9 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
     c.patterns.add(s)
   if isAnon:
     n.transitionSonsKind(nkLambda)
-    result.typ() = s.typ
+    result.typ = s.typ
     if optOwnedRefs in c.config.globalOptions:
-      result.typ() = makeVarType(c, result.typ, tyOwned)
+      result.typ = makeVarType(c, result.typ, tyOwned)
   elif isTopLevel(c) and s.kind != skIterator and s.typ.callConv == ccClosure:
     localError(c.config, s.info, "'.closure' calling convention for top level routines is invalid")
 
@@ -2622,15 +2622,14 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
 proc determineType(c: PContext, s: PSym) =
   if s.typ != nil: return
   #if s.magic != mNone: return
-  if s.ast.isNil and sfForward notin s.flags:
-    globalError(c.config, s.info, errIllFormedAstX, "symbol of kind " & $s.kind & " has no implementation")
+  #if s.ast.isNil: return
   discard semProcAux(c, s.ast, s.kind, {})
 
 proc semIterator(c: PContext, n: PNode): PNode =
   # gensym'ed iterator?
   if n[namePos].kind == nkSym:
     # gensym'ed iterators might need to become closure iterators:
-    setOwner(n[namePos].sym, getCurrOwner(c))
+    n[namePos].sym.owner = getCurrOwner(c)
     n[namePos].sym.transitionRoutineSymKind(skIterator)
   result = semProcAux(c, n, skIterator, iteratorPragmas)
   # bug #7093: if after a macro transformation we don't have an
@@ -2651,7 +2650,7 @@ proc semIterator(c: PContext, n: PNode): PNode =
   if n[bodyPos].kind == nkEmpty and s.magic == mNone and c.inConceptDecl == 0:
     localError(c.config, n.info, errImplOfXexpected % s.name.s)
   if optOwnedRefs in c.config.globalOptions and result.typ != nil:
-    result.typ() = makeVarType(c, result.typ, tyOwned)
+    result.typ = makeVarType(c, result.typ, tyOwned)
     result.typ.callConv = ccClosure
 
 proc semProc(c: PContext, n: PNode): PNode =
@@ -2782,7 +2781,7 @@ proc semPragmaBlock(c: PContext, n: PNode; expectedType: PType = nil): PNode =
   n[1] = semExpr(c, n[1], expectedType = expectedType)
   dec c.inUncheckedAssignSection, inUncheckedAssignSection
   result = n
-  result.typ() = n[1].typ
+  result.typ = n[1].typ
   for i in 0..<pragmaList.len:
     case whichPragma(pragmaList[i])
     of wLine: setInfoRecursive(result, pragmaList[i].info)
@@ -2867,14 +2866,14 @@ proc semStmtList(c: PContext, n: PNode, flags: TExprFlags, expectedType: PType =
       else: discard
     if n[i].typ == c.enforceVoidContext: #or usesResult(n[i]):
       voidContext = true
-      n.typ() = c.enforceVoidContext
+      n.typ = c.enforceVoidContext
     if i == last and (n.len == 1 or ({efWantValue, efInTypeof} * flags != {})):
-      n.typ() = n[i].typ
+      n.typ = n[i].typ
       if not isEmptyType(n.typ): n.transitionSonsKind(nkStmtListExpr)
     elif i != last or voidContext:
       discardCheck(c, n[i], flags)
     else:
-      n.typ() = n[i].typ
+      n.typ = n[i].typ
       if not isEmptyType(n.typ): n.transitionSonsKind(nkStmtListExpr)
     var m = n[i]
     while m.kind in {nkStmtListExpr, nkStmtList} and m.len > 0: # from templates

compiler/semtempl.nim

@@ -237,10 +237,10 @@ proc semTemplSymbol(c: var TemplCtx, n: PNode, s: PSym; isField, isAmbiguous: bo
         if result.kind == nkSym:
           result = newOpenSym(result)
         else:
-          result.typ() = nil
+          result.typ = nil
       else:
         result.flags.incl nfDisabledOpenSym
-        result.typ() = nil
+        result.typ = nil
   of skGenericParam:
     if isField and sfGenSym in s.flags: result = n
     else:
@@ -250,7 +250,7 @@ proc semTemplSymbol(c: var TemplCtx, n: PNode, s: PSym; isField, isAmbiguous: bo
           result = newOpenSym(result)
         else:
           result.flags.incl nfDisabledOpenSym
-          result.typ() = nil
+          result.typ = nil
   of skParam:
     result = n
   of skType:
@@ -268,10 +268,10 @@ proc semTemplSymbol(c: var TemplCtx, n: PNode, s: PSym; isField, isAmbiguous: bo
           if result.kind == nkSym:
             result = newOpenSym(result)
           else:
-            result.typ() = nil
+            result.typ = nil
         else:
           result.flags.incl nfDisabledOpenSym
-          result.typ() = nil
+          result.typ = nil
   else:
     if isField and sfGenSym in s.flags: result = n
     else:
@@ -281,7 +281,7 @@ proc semTemplSymbol(c: var TemplCtx, n: PNode, s: PSym; isField, isAmbiguous: bo
           result = newOpenSym(result)
         else:
           result.flags.incl nfDisabledOpenSym
-          result.typ() = nil
+          result.typ = nil
     # Issue #12832
     when defined(nimsuggest):
       suggestSym(c.c.graph, n.info, s, c.c.graph.usageSym, false)
@@ -535,20 +535,13 @@ proc semTemplBody(c: var TemplCtx, n: PNode): PNode =
   of nkConverterDef:
     result = semRoutineInTemplBody(c, n, skConverter)
   of nkPragmaExpr:
-    result = semTemplBodySons(c, n)
+    result[0] = semTemplBody(c, n[0])
   of nkPostfix:
     result[1] = semTemplBody(c, n[1])
   of nkPragma:
-    for i in 0 ..< n.len:
-      let x = n[i]
-      let prag = whichPragma(x)
-      if prag == wInvalid:
-        # only sem if not a language-level pragma 
-        result[i] = semTemplBody(c, x)
-      elif x.kind in nkPragmaCallKinds:
-        # is pragma, but value still needs to be checked
-        for j in 1 ..< x.len:
-          x[j] = semTemplBody(c, x[j])
+    for x in n:
+      if x.kind == nkExprColonExpr:
+        x[1] = semTemplBody(c, x[1])
   of nkBracketExpr:
     if n.typ == nil:
       # if a[b] is nested inside a typed expression, don't convert it

compiler/semtypes.nim

@@ -84,7 +84,6 @@ proc semEnum(c: PContext, n: PNode, prev: PType): PType =
   let isPure = result.sym != nil and sfPure in result.sym.flags
   var symbols: TStrTable = initStrTable()
   var hasNull = false
-  var needsReorder = false
   for i in 1..<n.len:
     if n[i].kind == nkEmpty: continue
     var useAutoCounter = false
@@ -123,9 +122,7 @@ proc semEnum(c: PContext, n: PNode, prev: PType): PType =
         else:
           localError(c.config, v.info, errOrdinalTypeExpected % typeToString(v.typ, preferDesc))
       if i != 1:
-        if x != counter:
-          needsReorder = true
-          incl(result.flags, tfEnumHasHoles)
+        if x != counter: incl(result.flags, tfEnumHasHoles)
       e.ast = strVal # might be nil
       counter = x
     of nkSym:
@@ -176,13 +173,6 @@ proc semEnum(c: PContext, n: PNode, prev: PType): PType =
         localError(c.config, n[i].info, errOverflowInEnumX % [e.name.s, $high(typeof(counter))])
     else:
       inc(counter)
-
-  if needsReorder:
-    result.n.sons.sort(
-      proc (x, y: PNode): int =
-        result = cmp(x.sym.position, y.sym.position)
-    )
-
   if isPure and sfExported in result.sym.flags:
     addPureEnum(c, LazySym(sym: result.sym))
   if tfNotNil in e.typ.flags and not hasNull:
@@ -257,39 +247,27 @@ proc isRecursiveType(t: PType, cycleDetector: var IntSet): bool =
   else:
     return false
 
-proc annotateClosureConv(n: PNode) =
-  case n.kind
-  of {nkNone..nkNilLit}:
-    discard
-  of nkTupleConstr:
-    if n.typ.kind == tyProc and n.typ.callConv == ccClosure and
-        n[0].typ.kind == tyProc and n[0].typ.callConv != ccClosure:
-      # restores `transf.generateThunk`
-      n[0] = newTreeIT(nkHiddenSubConv, n[0].info, n.typ,
-                       newNodeI(nkEmpty, n[0].info), n[0])
-      n.transitionSonsKind(nkClosure)
-      n.flags.incl nfTransf
-  else:
-    for i in 0..<n.len:
-      annotateClosureConv(n[i])
-
-proc fitDefaultNode(c: PContext, n: var PNode, expectedType: PType) =
+proc fitDefaultNode(c: PContext, n: PNode): PType =
   inc c.inStaticContext
-  n = semConstExpr(c, n, expectedType = expectedType)
-  let oldType = n.typ
-  n.flags.incl nfSem
-  if expectedType != nil and oldType != expectedType:
-    n = fitNodeConsiderViewType(c, expectedType, n, n.info)
-    changeType(c, n, expectedType, true) # infer types for default fields value
-      # bug #22926; be cautious that it uses `semConstExpr` to
-      # evaulate the default fields; it's only natural to use
-      # `changeType` to infer types for constant values
-      # that's also the reason why we don't use `semExpr` to check
-      # the type since two overlapping error messages might be produced
-  annotateClosureConv(n)
+  let expectedType = if n[^2].kind != nkEmpty: semTypeNode(c, n[^2], nil) else: nil
+  n[^1] = semConstExpr(c, n[^1], expectedType = expectedType)
+  let oldType = n[^1].typ
+  n[^1].flags.incl nfSem
+  if n[^2].kind != nkEmpty:
+    if expectedType != nil and oldType != expectedType:
+      n[^1] = fitNodeConsiderViewType(c, expectedType, n[^1], n[^1].info)
+      changeType(c, n[^1], expectedType, true) # infer types for default fields value
+        # bug #22926; be cautious that it uses `semConstExpr` to
+        # evaulate the default fields; it's only natural to use
+        # `changeType` to infer types for constant values
+        # that's also the reason why we don't use `semExpr` to check
+        # the type since two overlapping error messages might be produced
+    result = n[^1].typ
+  else:
+    result = n[^1].typ
   # xxx any troubles related to defaults fields, consult `semConst` for a potential answer
-  if n.kind != nkNilLit:
-    typeAllowedCheck(c, n.info, n.typ, skConst, {taProcContextIsNotMacro, taIsDefaultField})
+  if n[^1].kind != nkNilLit:
+    typeAllowedCheck(c, n.info, result, skConst, {taProcContextIsNotMacro, taIsDefaultField})
   dec c.inStaticContext
 
 proc isRecursiveType*(t: PType): bool =
@@ -502,7 +480,7 @@ proc firstRange(config: ConfigRef, t: PType): PNode =
     result = newFloatNode(nkFloatLit, firstFloat(t))
   else:
     result = newIntNode(nkIntLit, firstOrd(config, t))
-  result.typ() = t
+  result.typ = t
 
 proc semTuple(c: PContext, n: PNode, prev: PType): PType =
   var typ: PType
@@ -516,14 +494,7 @@ proc semTuple(c: PContext, n: PNode, prev: PType): PType =
     checkMinSonsLen(a, 3, c.config)
     var hasDefaultField = a[^1].kind != nkEmpty
     if hasDefaultField:
-      typ = if a[^2].kind != nkEmpty: semTypeNode(c, a[^2], nil) else: nil
-      if c.inGenericContext > 0:
-        a[^1] = semExprWithType(c, a[^1], {efDetermineType, efAllowSymChoice}, typ)
-        if typ == nil:
-          typ = a[^1].typ
-      else:
-        fitDefaultNode(c, a[^1], typ)
-        typ = a[^1].typ
+      typ = fitDefaultNode(c, a)
     elif a[^2].kind != nkEmpty:
       typ = semTypeNode(c, a[^2], nil)
       if c.graph.config.isDefined("nimPreviewRangeDefault") and typ.skipTypes(abstractInst).kind == tyRange:
@@ -615,14 +586,9 @@ proc semBranchRange(c: PContext, n, a, b: PNode, covered: var Int128): PNode =
   let bc = semConstExpr(c, b)
   if ac.kind in {nkStrLit..nkTripleStrLit} or bc.kind in {nkStrLit..nkTripleStrLit}:
     localError(c.config, b.info, "range of string is invalid")
-  var at = fitNode(c, n[0].typ, ac, ac.info).skipConvTakeType
-  var bt = fitNode(c, n[0].typ, bc, bc.info).skipConvTakeType
-  # the calls to fitNode may introduce calls to converters
-  # mirrored with semCaseBranch for single elements
-  if at.kind in {nkHiddenCallConv, nkHiddenStdConv, nkHiddenSubConv}:
-    at = semConstExpr(c, at)
-  if bt.kind in {nkHiddenCallConv, nkHiddenStdConv, nkHiddenSubConv}:
-    bt = semConstExpr(c, bt)
+  let at = fitNode(c, n[0].typ, ac, ac.info).skipConvTakeType
+  let bt = fitNode(c, n[0].typ, bc, bc.info).skipConvTakeType
+
   result = newNodeI(nkRange, a.info)
   result.add(at)
   result.add(bt)
@@ -670,8 +636,8 @@ proc semCaseBranch(c: PContext, n, branch: PNode, branchIndex: int,
         checkMinSonsLen(n, 1, c.config)
         var tmp = fitNode(c, n[0].typ, r, r.info)
         # the call to fitNode may introduce a call to a converter
-        # mirrored with semBranchRange
-        if tmp.kind in {nkHiddenCallConv, nkHiddenStdConv, nkHiddenSubConv}:
+        if tmp.kind == nkHiddenCallConv or
+            (tmp.kind == nkHiddenStdConv and n[0].typ.kind == tyCstring):
           tmp = semConstExpr(c, tmp)
         branch[i] = skipConv(tmp)
         inc(covered)
@@ -887,15 +853,8 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var IntSet, pos: var int,
     var typ: PType
     var hasDefaultField = n[^1].kind != nkEmpty
     if hasDefaultField:
-      typ = if n[^2].kind != nkEmpty: semTypeNode(c, n[^2], nil) else: nil
-      if c.inGenericContext > 0:
-        n[^1] = semExprWithType(c, n[^1], {efDetermineType, efAllowSymChoice}, typ)
-        if typ == nil:
-          typ = n[^1].typ
-      else:
-        fitDefaultNode(c, n[^1], typ)
-        typ = n[^1].typ
-        propagateToOwner(rectype, typ)
+      typ = fitDefaultNode(c, n)
+      propagateToOwner(rectype, typ)
     elif n[^2].kind == nkEmpty:
       localError(c.config, n.info, errTypeExpected)
       typ = errorType(c)
@@ -1132,7 +1091,7 @@ proc addParamOrResult(c: PContext, param: PSym, kind: TSymKind) =
     if sfGenSym in param.flags:
       # bug #XXX, fix the gensym'ed parameters owner:
       if param.owner == nil:
-        setOwner(param, getCurrOwner(c))
+        param.owner = getCurrOwner(c)
     else: addDecl(c, param)
 
 template shouldHaveMeta(t) =
@@ -1408,25 +1367,14 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
           "either use ';' (semicolon) or explicitly write each default value")
         message(c.config, a.info, warnImplicitDefaultValue, msg)
       block determineType:
-        var canBeVoid = false
-        if kind == skTemplate:
-          if typ != nil and typ.kind == tyUntyped:
-            # don't do any typechecking or assign a type for
-            # `untyped` parameter default value
-            break determineType
-          elif hasUnresolvedArgs(c, def):
-            # template default value depends on other parameter
-            # don't do any typechecking
-            def.typ() = makeTypeFromExpr(c, def.copyTree)
-            break determineType
-          elif typ != nil and typ.kind == tyTyped:
-            canBeVoid = true
+        if kind == skTemplate and hasUnresolvedArgs(c, def):
+          # template default value depends on other parameter
+          # don't do any typechecking
+          def.typ = makeTypeFromExpr(c, def.copyTree)
+          break determineType
         let isGeneric = isCurrentlyGeneric()
         inc c.inGenericContext, ord(isGeneric)
-        if canBeVoid:
-          def = semExpr(c, def, {efDetermineType, efAllowSymChoice}, typ)
-        else:
-          def = semExprWithType(c, def, {efDetermineType, efAllowSymChoice}, typ)
+        def = semExprWithType(c, def, {efDetermineType, efAllowSymChoice}, typ)
         dec c.inGenericContext, ord(isGeneric)
         if def.referencesAnotherParam(getCurrOwner(c)):
           def.flags.incl nfDefaultRefsParam
@@ -1446,7 +1394,7 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
           typ = newTypeS(tyTypeDesc, c, newTypeS(tyNone, c))
           typ.flags.incl tfCheckedForDestructor
 
-      elif def.typ != nil and def.typ.kind != tyFromExpr: # def.typ can be void
+      elif def.typ.kind != tyFromExpr:
         # if def.typ != nil and def.typ.kind != tyNone:
         # example code that triggers it:
         # proc sort[T](cmp: proc(a, b: T): int = cmp)
@@ -1555,7 +1503,7 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
         # XXX This rather hacky way keeps 'tflatmap' compiling:
         if tfHasMeta notin oldFlags:
           result.flags.excl tfHasMeta
-      result.n.typ() = r
+      result.n.typ = r
 
   if isCurrentlyGeneric():
     for n in genericParams:
@@ -1572,8 +1520,8 @@ proc semStmtListType(c: PContext, n: PNode, prev: PType): PType =
     n[i] = semStmt(c, n[i], {})
   if n.len > 0:
     result = semTypeNode(c, n[^1], prev)
-    n.typ() = result
-    n[^1].typ() = result
+    n.typ = result
+    n[^1].typ = result
   else:
     result = nil
 
@@ -1586,15 +1534,15 @@ proc semBlockType(c: PContext, n: PNode, prev: PType): PType =
   if n[0].kind notin {nkEmpty, nkSym}:
     addDecl(c, newSymS(skLabel, n[0], c))
   result = semStmtListType(c, n[1], prev)
-  n[1].typ() = result
-  n.typ() = result
+  n[1].typ = result
+  n.typ = result
   closeScope(c)
   c.p.breakInLoop = oldBreakInLoop
   dec(c.p.nestedBlockCounter)
 
 proc semGenericParamInInvocation(c: PContext, n: PNode): PType =
   result = semTypeNode(c, n, nil)
-  n.typ() = makeTypeDesc(c, result)
+  n.typ = makeTypeDesc(c, result)
 
 proc trySemObjectTypeForInheritedGenericInst(c: PContext, n: PNode, t: PType): bool =
   var
@@ -2006,7 +1954,7 @@ proc semTypeIdent(c: PContext, n: PNode): PSym =
         n.transitionNoneToSym()
         n.sym = result
         n.info = oldInfo
-        n.typ() = result.typ
+        n.typ = result.typ
     else:
       localError(c.config, n.info, "identifier expected")
       result = errorSym(c, n)
@@ -2214,7 +2162,7 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
       if s.kind != skError: localError(c.config, n.info, errTypeExpected)
       result = newOrPrevType(tyError, prev, c)
     elif s.kind == skParam and s.typ.kind == tyTypeDesc:
-      internalAssert c.config, s.typ.base.kind != tyNone
+      internalAssert c.config, s.typ.base.kind != tyNone and prev == nil
       result = s.typ.base
     elif prev == nil:
       result = s.typ
@@ -2238,7 +2186,7 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
         if s.kind == skType:
           s.typ
         else:
-          internalAssert c.config, s.typ.base.kind != tyNone
+          internalAssert c.config, s.typ.base.kind != tyNone and prev == nil
           s.typ.base
       let alias = maybeAliasType(c, t, prev)
       if alias != nil:
@@ -2305,7 +2253,7 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
     when false:
       localError(c.config, n.info, "type expected, but got: " & renderTree(n))
       result = newOrPrevType(tyError, prev, c)
-  n.typ() = result
+  n.typ = result
   dec c.inTypeContext
 
 proc setMagicType(conf: ConfigRef; m: PSym, kind: TTypeKind, size: int) =
@@ -2452,7 +2400,7 @@ proc semGenericParamList(c: PContext, n: PNode, father: PType = nil): PNode =
         else:
           # the following line fixes ``TV2*[T:SomeNumber=TR] = array[0..1, T]``
           # from manyloc/named_argument_bug/triengine:
-          def.typ() = def.typ.skipTypes({tyTypeDesc})
+          def.typ = def.typ.skipTypes({tyTypeDesc})
           if not containsGenericType(def.typ):
             def = fitNode(c, typ, def, def.info)
 

compiler/semtypinst.nim

@@ -12,7 +12,7 @@
 import std / tables
 
 import ast, astalgo, msgs, types, magicsys, semdata, renderer, options,
-  lineinfos, modulegraphs, layeredtable
+  lineinfos, modulegraphs
 
 when defined(nimPreviewSlimSystem):
   import std/assertions
@@ -65,6 +65,10 @@ proc cacheTypeInst(c: PContext; inst: PType) =
   addToGenericCache(c, gt.sym, inst)
 
 type
+  LayeredIdTable* {.acyclic.} = ref object
+    topLayer*: TypeMapping
+    nextLayer*: LayeredIdTable
+
   TReplTypeVars* = object
     c*: PContext
     typeMap*: LayeredIdTable  # map PType to PType
@@ -84,8 +88,23 @@ proc replaceTypeVarsTAux(cl: var TReplTypeVars, t: PType): PType
 proc replaceTypeVarsS(cl: var TReplTypeVars, s: PSym, t: PType): PSym
 proc replaceTypeVarsN*(cl: var TReplTypeVars, n: PNode; start=0; expectedType: PType = nil): PNode
 
+proc initLayeredTypeMap*(pt: sink TypeMapping): LayeredIdTable =
+  result = LayeredIdTable()
+  result.topLayer = pt
+
 proc newTypeMapLayer*(cl: var TReplTypeVars): LayeredIdTable =
-  result = newTypeMapLayer(cl.typeMap)
+  result = LayeredIdTable(nextLayer: cl.typeMap, topLayer: initTable[ItemId, PType]())
+
+proc lookup(typeMap: LayeredIdTable, key: PType): PType =
+  result = nil
+  var tm = typeMap
+  while tm != nil:
+    result = getOrDefault(tm.topLayer, key.itemId)
+    if result != nil: return
+    tm = tm.nextLayer
+
+template put(typeMap: LayeredIdTable, key, value: PType) =
+  typeMap.topLayer[key.itemId] = value
 
 template checkMetaInvariants(cl: TReplTypeVars, t: PType) = # noop code
   when false:
@@ -110,7 +129,7 @@ proc prepareNode*(cl: var TReplTypeVars, n: PNode): PNode =
     return if tfUnresolved in t.flags: prepareNode(cl, t.n)
            else: t.n
   result = copyNode(n)
-  result.typ() = t
+  result.typ = t
   if result.kind == nkSym:
     result.sym =
       if n.typ != nil and n.typ == n.sym.typ:
@@ -264,7 +283,7 @@ proc replaceTypeVarsN(cl: var TReplTypeVars, n: PNode; start=0; expectedType: PT
     if n.typ.kind == tyFromExpr:
       # type of node should not be evaluated as a static value
       n.typ.flags.incl tfNonConstExpr
-    result.typ() = replaceTypeVarsT(cl, n.typ)
+    result.typ = replaceTypeVarsT(cl, n.typ)
     checkMetaInvariants(cl, result.typ)
   case n.kind
   of nkNone..pred(nkSym), succ(nkSym)..nkNilLit:
@@ -276,11 +295,6 @@ proc replaceTypeVarsN(cl: var TReplTypeVars, n: PNode; start=0; expectedType: PT
         replaceTypeVarsS(cl, n.sym, result.typ)
       else:
         replaceTypeVarsS(cl, n.sym, replaceTypeVarsT(cl, n.sym.typ))
-    if result.sym.kind == skField and result.sym.ast != nil and
-        (cl.owner == nil or result.sym.owner == cl.owner):
-      # instantiate default value of object/tuple field
-      cl.c.fitDefaultNode(cl.c, result.sym.ast, result.sym.typ)
-      result.sym.typ = result.sym.ast.typ
     # sym type can be nil if was gensym created by macro, see #24048
     if result.sym.typ != nil and result.sym.typ.kind == tyVoid:
       # don't add the 'void' field
@@ -363,7 +377,7 @@ proc replaceTypeVarsS(cl: var TReplTypeVars, s: PSym, t: PType): PSym =
   result = copySym(s, cl.c.idgen)
   incl(result.flags, sfFromGeneric)
   #idTablePut(cl.symMap, s, result)
-  setOwner(result, s.owner)
+  result.owner = s.owner
   result.typ = t
   if result.kind != skType:
     result.ast = replaceTypeVarsN(cl, s.ast)
@@ -486,7 +500,7 @@ proc handleGenericInvocation(cl: var TReplTypeVars, t: PType): PType =
   newbody.flags = newbody.flags + (t.flags + body.flags - tfInstClearedFlags)
   result.flags = result.flags + newbody.flags - tfInstClearedFlags
 
-  setToPreviousLayer(cl.typeMap)
+  cl.typeMap = cl.typeMap.nextLayer
 
   # This is actually wrong: tgeneric_closure fails with this line:
   #newbody.callConv = body.callConv
@@ -701,7 +715,7 @@ proc replaceTypeVarsTAux(cl: var TReplTypeVars, t: PType): PType =
     if not cl.allowMetaTypes and result.n != nil and
         result.base.kind != tyNone:
       result.n = cl.c.semConstExpr(cl.c, result.n)
-      result.n.typ() = result.base
+      result.n.typ = result.base
 
   of tyGenericInst, tyUserTypeClassInst:
     bailout()
@@ -777,19 +791,19 @@ proc initTypeVars*(p: PContext, typeMap: LayeredIdTable, info: TLineInfo;
             localCache: initTypeMapping(), typeMap: typeMap,
             info: info, c: p, owner: owner)
 
-proc replaceTypesInBody*(p: PContext, pt: LayeredIdTable, n: PNode;
+proc replaceTypesInBody*(p: PContext, pt: TypeMapping, n: PNode;
                          owner: PSym, allowMetaTypes = false,
                          fromStaticExpr = false, expectedType: PType = nil): PNode =
-  var typeMap = shallowCopy(pt) # use previous bindings without writing to them
+  var typeMap = initLayeredTypeMap(pt)
   var cl = initTypeVars(p, typeMap, n.info, owner)
   cl.allowMetaTypes = allowMetaTypes
   pushInfoContext(p.config, n.info)
   result = replaceTypeVarsN(cl, n, expectedType = expectedType)
   popInfoContext(p.config)
 
-proc prepareTypesInBody*(p: PContext, pt: LayeredIdTable, n: PNode;
+proc prepareTypesInBody*(p: PContext, pt: TypeMapping, n: PNode;
                          owner: PSym = nil): PNode =
-  var typeMap = shallowCopy(pt) # use previous bindings without writing to them
+  var typeMap = initLayeredTypeMap(pt)
   var cl = initTypeVars(p, typeMap, n.info, owner)
   pushInfoContext(p.config, n.info)
   result = prepareNode(cl, n)
@@ -822,13 +836,13 @@ proc recomputeFieldPositions*(t: PType; obj: PNode; currPosition: var int) =
     inc currPosition
   else: discard "cannot happen"
 
-proc generateTypeInstance*(p: PContext, pt: LayeredIdTable, info: TLineInfo,
+proc generateTypeInstance*(p: PContext, pt: TypeMapping, info: TLineInfo,
                            t: PType): PType =
   # Given `t` like Foo[T]
   # pt: Table with type mappings: T -> int
   # Desired result: Foo[int]
   # proc (x: T = 0); T -> int ---->  proc (x: int = 0)
-  var typeMap = shallowCopy(pt) # use previous bindings without writing to them
+  var typeMap = initLayeredTypeMap(pt)
   var cl = initTypeVars(p, typeMap, info, nil)
   pushInfoContext(p.config, info)
   result = replaceTypeVarsT(cl, t)
@@ -838,15 +852,15 @@ proc generateTypeInstance*(p: PContext, pt: LayeredIdTable, info: TLineInfo,
     var position = 0
     recomputeFieldPositions(objType, objType.n, position)
 
-proc prepareMetatypeForSigmatch*(p: PContext, pt: LayeredIdTable, info: TLineInfo,
+proc prepareMetatypeForSigmatch*(p: PContext, pt: TypeMapping, info: TLineInfo,
                                  t: PType): PType =
-  var typeMap = shallowCopy(pt) # use previous bindings without writing to them
+  var typeMap = initLayeredTypeMap(pt)
   var cl = initTypeVars(p, typeMap, info, nil)
   cl.allowMetaTypes = true
   pushInfoContext(p.config, info)
   result = replaceTypeVarsT(cl, t)
   popInfoContext(p.config)
 
-template generateTypeInstance*(p: PContext, pt: LayeredIdTable, arg: PNode,
+template generateTypeInstance*(p: PContext, pt: TypeMapping, arg: PNode,
                                t: PType): untyped =
   generateTypeInstance(p, pt, arg.info, t)

compiler/sigmatch.nim

@@ -13,7 +13,7 @@
 import
   ast, astalgo, semdata, types, msgs, renderer, lookups, semtypinst,
   magicsys, idents, lexer, options, parampatterns, trees,
-  linter, lineinfos, lowerings, modulegraphs, concepts, layeredtable
+  linter, lineinfos, lowerings, modulegraphs, concepts
 
 import std/[intsets, strutils, tables]
 
@@ -56,7 +56,7 @@ type
     calleeScope*: int        # scope depth:
                              # is this a top-level symbol or a nested proc?
     call*: PNode             # modified call
-    bindings*: LayeredIdTable # maps types to types
+    bindings*: TypeMapping   # maps types to types
     magic*: TMagic           # magic of operation
     baseTypeMatch: bool      # needed for conversions from T to openarray[T]
                              # for example
@@ -85,9 +85,6 @@ type
     inheritancePenalty: int
     firstMismatch*: MismatchInfo # mismatch info for better error messages
     diagnosticsEnabled*: bool
-    newlyTypedOperands*: seq[int]
-      ## indexes of arguments that are newly typechecked in this match
-      ## used for type bound op additions
 
   TTypeRelFlag* = enum
     trDontBind
@@ -117,21 +114,21 @@ proc initCandidateAux(ctx: PContext,
 proc initCandidate*(ctx: PContext, callee: PType): TCandidate =
   result = initCandidateAux(ctx, callee)
   result.calleeSym = nil
-  result.bindings = initLayeredTypeMap()
+  result.bindings = initTypeMapping()
 
 proc put(c: var TCandidate, key, val: PType) {.inline.} =
   ## Given: proc foo[T](x: T); foo(4)
   ## key: 'T'
   ## val: 'int' (typeof(4))
   when false:
-    let old = lookup(c.bindings, key)
+    let old = idTableGet(c.bindings, key)
     if old != nil:
       echo "Putting ", typeToString(key), " ", typeToString(val), " and old is ", typeToString(old)
       if typeToString(old) == "float32":
         writeStackTrace()
     if c.c.module.name.s == "temp3":
       echo "binding ", key, " -> ", val
-  put(c.bindings, key, val.skipIntLit(c.c.idgen))
+  idTablePut(c.bindings, key, val.skipIntLit(c.c.idgen))
 
 proc typeRel*(c: var TCandidate, f, aOrig: PType,
               flags: TTypeRelFlags = {}): TTypeRelation
@@ -141,7 +138,7 @@ proc matchGenericParam(m: var TCandidate, formal: PType, n: PNode) =
   if m.c.inGenericContext > 0:
     # don't match yet-unresolved generic instantiations
     while arg != nil and arg.kind == tyGenericParam:
-      arg = lookup(m.bindings, arg)
+      arg = idTableGet(m.bindings, arg)
     if arg == nil or arg.containsUnresolvedType:
       m.state = csNoMatch
       return
@@ -203,9 +200,6 @@ proc matchGenericParams*(m: var TCandidate, binding: PNode, callee: PSym) =
     elif tfImplicitTypeParam in paramSym.typ.flags:
       # not a mismatch, but can't create sym
       m.state = csEmpty
-      m.firstMismatch.kind = kMissingGenericParam
-      m.firstMismatch.arg = i + 1
-      m.firstMismatch.formal = paramSym
       return
     else:
       m.state = csNoMatch
@@ -224,7 +218,7 @@ proc copyingEraseVoidParams(m: TCandidate, t: var PType) =
     var f = original[i]
     var isVoidParam = f.kind == tyVoid
     if not isVoidParam:
-      let prev = lookup(m.bindings, f)
+      let prev = idTableGet(m.bindings, f)
       if prev != nil: f = prev
       isVoidParam = f.kind == tyVoid
     if isVoidParam:
@@ -252,7 +246,7 @@ proc initCandidate*(ctx: PContext, callee: PSym,
   result.diagnostics = @[] # if diagnosticsEnabled: @[] else: nil
   result.diagnosticsEnabled = diagnosticsEnabled
   result.magic = result.calleeSym.magic
-  result.bindings = initLayeredTypeMap()
+  result.bindings = initTypeMapping()
   if binding != nil and callee.kind in routineKinds:
     matchGenericParams(result, binding, callee)
     let genericMatch = result.state
@@ -276,7 +270,7 @@ proc newCandidate*(ctx: PContext, callee: PSym,
 proc newCandidate*(ctx: PContext, callee: PType): TCandidate =
   result = initCandidate(ctx, callee)
 
-proc shallowCopyCandidate(dest: var TCandidate, src: TCandidate) =
+proc copyCandidate(dest: var TCandidate, src: TCandidate) =
   dest.c = src.c
   dest.exactMatches = src.exactMatches
   dest.subtypeMatches = src.subtypeMatches
@@ -288,7 +282,7 @@ proc shallowCopyCandidate(dest: var TCandidate, src: TCandidate) =
   dest.calleeSym = src.calleeSym
   dest.call = copyTree(src.call)
   dest.baseTypeMatch = src.baseTypeMatch
-  dest.bindings = shallowCopy(src.bindings)
+  dest.bindings = src.bindings
 
 proc checkGeneric(a, b: TCandidate): int =
   let c = a.c
@@ -450,11 +444,11 @@ template describeArgImpl(c: PContext, n: PNode, i: int, startIdx = 1; prefer = p
       arg = c.semTryExpr(c, n[i][1])
       if arg == nil:
         arg = n[i][1]
-        arg.typ() = newTypeS(tyUntyped, c)
+        arg.typ = newTypeS(tyUntyped, c)
       else:
         if arg.typ == nil:
-          arg.typ() = newTypeS(tyVoid, c)
-        n[i].typ() = arg.typ
+          arg.typ = newTypeS(tyVoid, c)
+        n[i].typ = arg.typ
         n[i][1] = arg
   else:
     if arg.typ.isNil and arg.kind notin {nkStmtList, nkDo, nkElse,
@@ -463,10 +457,10 @@ template describeArgImpl(c: PContext, n: PNode, i: int, startIdx = 1; prefer = p
       arg = c.semTryExpr(c, n[i])
       if arg == nil:
         arg = n[i]
-        arg.typ() = newTypeS(tyUntyped, c)
+        arg.typ = newTypeS(tyUntyped, c)
       else:
         if arg.typ == nil:
-          arg.typ() = newTypeS(tyVoid, c)
+          arg.typ = newTypeS(tyVoid, c)
         n[i] = arg
   if arg.typ != nil and arg.typ.kind == tyError: return
   result.add argTypeToString(arg, prefer)
@@ -493,7 +487,7 @@ proc concreteType(c: TCandidate, t: PType; f: PType = nil): PType =
     result = t
     if c.isNoCall: return
     while true:
-      result = lookup(c.bindings, t)
+      result = idTableGet(c.bindings, t)
       if result == nil:
         break # it's ok, no match
         # example code that triggers it:
@@ -638,7 +632,7 @@ proc genericParamPut(c: var TCandidate; last, fGenericOrigin: PType) =
   if fGenericOrigin != nil and last.kind == tyGenericInst and
      last.kidsLen-1 == fGenericOrigin.kidsLen:
     for i in FirstGenericParamAt..<fGenericOrigin.kidsLen:
-      let x = lookup(c.bindings, fGenericOrigin[i])
+      let x = idTableGet(c.bindings, fGenericOrigin[i])
       if x == nil:
         put(c, fGenericOrigin[i], last[i])
 
@@ -776,7 +770,7 @@ proc procParamTypeRel(c: var TCandidate; f, a: PType): TTypeRelation =
     a = a
 
   if a.isMetaType:
-    let aResolved = lookup(c.bindings, a)
+    let aResolved = idTableGet(c.bindings, a)
     if aResolved != nil:
       a = aResolved
   if a.isMetaType:
@@ -902,7 +896,7 @@ proc matchUserTypeClass*(m: var TCandidate; ff, a: PType): PType =
         typeParamName = ff.base[i-1].sym.name
         typ = ff[i]
         param: PSym = nil
-        alreadyBound = lookup(m.bindings, typ)
+        alreadyBound = idTableGet(m.bindings, typ)
 
       if alreadyBound != nil: typ = alreadyBound
 
@@ -1087,7 +1081,7 @@ proc inferStaticParam*(c: var TCandidate, lhs: PNode, rhs: BiggestInt): bool =
     else: discard
 
   elif lhs.kind == nkSym and lhs.typ.kind == tyStatic and
-      (lhs.typ.n == nil or lookup(c.bindings, lhs.typ) == nil):
+      (lhs.typ.n == nil or idTableGet(c.bindings, lhs.typ) == nil):
     var inferred = newTypeS(tyStatic, c.c, lhs.typ.elementType)
     inferred.n = newIntNode(nkIntLit, rhs)
     put(c, lhs.typ, inferred)
@@ -1243,7 +1237,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
 
       case f.kind
       of tyGenericParam:
-        var prev = lookup(c.bindings, f)
+        var prev = idTableGet(c.bindings, f)
         if prev != nil: candidate = prev
       of tyFromExpr:
         let computedType = tryResolvingStaticExpr(c, f.n).typ
@@ -1293,7 +1287,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
     return res
 
   template considerPreviousT(body: untyped) =
-    var prev = lookup(c.bindings, f)
+    var prev = idTableGet(c.bindings, f)
     if prev == nil: body
     else: return typeRel(c, prev, a, flags)
 
@@ -1427,7 +1421,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
       var fRange = f.indexType
       var aRange = a.indexType
       if fRange.kind in {tyGenericParam, tyAnything}:
-        var prev = lookup(c.bindings, fRange)
+        var prev = idTableGet(c.bindings, fRange)
         if prev == nil:
           if typeRel(c, fRange, aRange) == isNone:
             return isNone
@@ -1567,12 +1561,11 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
       else:
         result = typeRel(c, f[0], a[0], flags)
         if result < isGeneric:
-          if tfIsConstructor notin a.flags:
-            # set['a'..'z'] and set[char] have different representations
+          if result <= isConvertible:
+            result = isNone
+          elif tfIsConstructor notin a.flags:
+            # set constructors are a bit special...
             result = isNone
-          else:
-            # but we can convert individual elements of the constructor
-            result = isConvertible
   of tyPtr, tyRef:
     a = reduceToBase(a)
     if a.kind == f.kind:
@@ -1661,7 +1654,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
     else:
       result = isNone
   of tyGenericInst:
-    var prev = lookup(c.bindings, f)
+    var prev = idTableGet(c.bindings, f)
     let origF = f
     var f = if prev == nil: f else: prev
 
@@ -1793,14 +1786,14 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
         #
         # we steal the generic parameters from the tyGenericBody:
         for i in 1..<f.len:
-          let x = lookup(c.bindings, genericBody[i-1])
+          let x = idTableGet(c.bindings, genericBody[i-1])
           if x == nil:
             discard "maybe fine (for e.g. a==tyNil)"
           elif x.kind in {tyGenericInvocation, tyGenericParam}:
             internalError(c.c.graph.config, "wrong instantiated type!")
           else:
             let key = f[i]
-            let old = lookup(c.bindings, key)
+            let old = idTableGet(c.bindings, key)
             if old == nil:
               put(c, key, x)
             elif typeRel(c, old, x, flags + {trDontBind}) == isNone:
@@ -1905,11 +1898,8 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
         else:
           result = isNone
   of tyConcept:
-    if a.kind == tyConcept and sameType(f, a):
-      result = isGeneric
-    else:
-      result = if concepts.conceptMatch(c.c, f, a, c.bindings, nil): isGeneric
-               else: isNone
+    result = if concepts.conceptMatch(c.c, f, a, c.bindings, nil): isGeneric
+             else: isNone
   of tyCompositeTypeClass:
     considerPreviousT:
       let roota = a.skipGenericAlias
@@ -1928,7 +1918,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
         result = isGeneric
   of tyGenericParam:
     let doBindGP = doBind or trBindGenericParam in flags
-    var x = lookup(c.bindings, f)
+    var x = idTableGet(c.bindings, f)
     if x == nil:
       if c.callee.kind == tyGenericBody and not c.typedescMatched:
         # XXX: The fact that generic types currently use tyGenericParam for
@@ -2008,7 +1998,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
       c.inheritancePenalty = inheritancePenaltyOld
       if result > isGeneric: result = isGeneric
   of tyStatic:
-    let prev = lookup(c.bindings, f)
+    let prev = idTableGet(c.bindings, f)
     if prev == nil:
       if aOrig.kind == tyStatic:
         if c.c.inGenericContext > 0 and aOrig.n == nil and not c.isNoCall:
@@ -2022,7 +2012,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
             var r = tryResolvingStaticExpr(c, f.n)
             if r == nil: r = f.n
             if not exprStructuralEquivalent(r, aOrig.n) and
-                not (aOrig.n != nil and aOrig.n.kind == nkIntLit and
+                not (aOrig.n.kind == nkIntLit and
                   inferStaticParam(c, r, aOrig.n.intVal)):
               result = isNone
         elif f.base.kind == tyGenericParam:
@@ -2070,7 +2060,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
         c.inferredTypes.add f
         f.add a
   of tyTypeDesc:
-    var prev = lookup(c.bindings, f)
+    var prev = idTableGet(c.bindings, f)
     if prev == nil:
       # proc foo(T: typedesc, x: T)
       # when `f` is an unresolved typedesc, `a` could be any
@@ -2161,7 +2151,7 @@ proc cmpTypes*(c: PContext, f, a: PType): TTypeRelation =
 
 proc getInstantiatedType(c: PContext, arg: PNode, m: TCandidate,
                          f: PType): PType =
-  result = lookup(m.bindings, f)
+  result = idTableGet(m.bindings, f)
   if result == nil:
     result = generateTypeInstance(c, m.bindings, arg, f)
   if result == nil:
@@ -2173,16 +2163,16 @@ proc implicitConv(kind: TNodeKind, f: PType, arg: PNode, m: TCandidate,
   result = newNodeI(kind, arg.info)
   if containsGenericType(f):
     if not m.matchedErrorType:
-      result.typ() = getInstantiatedType(c, arg, m, f).skipTypes({tySink})
+      result.typ = getInstantiatedType(c, arg, m, f).skipTypes({tySink})
     else:
-      result.typ() = errorType(c)
+      result.typ = errorType(c)
   else:
-    result.typ() = f.skipTypes({tySink})
+    result.typ = f.skipTypes({tySink})
   # keep varness
   if arg.typ != nil and arg.typ.kind == tyVar:
-    result.typ() = toVar(result.typ, tyVar, c.idgen)
+    result.typ = toVar(result.typ, tyVar, c.idgen)
   else:
-    result.typ() = result.typ.skipTypes({tyVar})
+    result.typ = result.typ.skipTypes({tyVar})
 
   if result.typ == nil: internalError(c.graph.config, arg.info, "implicitConv")
   result.add c.graph.emptyNode
@@ -2193,81 +2183,6 @@ proc implicitConv(kind: TNodeKind, f: PType, arg: PNode, m: TCandidate,
   else:
     result.add arg
 
-proc convertLiteral(kind: TNodeKind, c: PContext, m: TCandidate; n: PNode, newType: PType): PNode =
-  # based off changeType but generates implicit conversions instead
-  template addConsiderNil(s, node) =
-    let val = node
-    if val.isNil: return nil
-    s.add(val)
-  case n.kind
-  of nkCurly:
-    result = copyNode(n)
-    for i in 0..<n.len:
-      if n[i].kind == nkRange:
-        var x = copyNode(n[i])
-        x.addConsiderNil convertLiteral(kind, c, m, n[i][0], elemType(newType))
-        x.addConsiderNil convertLiteral(kind, c, m, n[i][1], elemType(newType))
-        result.add x
-      else:
-        result.addConsiderNil convertLiteral(kind, c, m, n[i], elemType(newType))
-    result.typ() = newType
-    return
-  of nkBracket:
-    result = copyNode(n)
-    for i in 0..<n.len:
-      result.addConsiderNil convertLiteral(kind, c, m, n[i], elemType(newType))
-    result.typ() = newType
-    return
-  of nkPar, nkTupleConstr:
-    let tup = newType.skipTypes({tyGenericInst, tyAlias, tySink, tyDistinct})
-    if tup.kind == tyTuple:
-      result = copyNode(n)
-      if n.len > 0 and n[0].kind == nkExprColonExpr:
-        # named tuple?
-        for i in 0..<n.len:
-          var name = n[i][0]
-          if name.kind != nkSym:
-            #globalError(c.config, name.info, "invalid tuple constructor")
-            return nil
-          if tup.n != nil:
-            var f = getSymFromList(tup.n, name.sym.name)
-            if f == nil:
-              #globalError(c.config, name.info, "unknown identifier: " & name.sym.name.s)
-              return nil
-            result.addConsiderNil convertLiteral(kind, c, m, n[i][1], f.typ)
-          else:
-            result.addConsiderNil convertLiteral(kind, c, m, n[i][1], tup[i])
-      else:
-        for i in 0..<n.len:
-          result.addConsiderNil convertLiteral(kind, c, m, n[i], tup[i])
-      result.typ() = newType
-      return
-  of nkCharLit..nkUInt64Lit:
-    if n.kind != nkUInt64Lit and not sameTypeOrNil(n.typ, newType) and isOrdinalType(newType):
-      let value = n.intVal
-      if value < firstOrd(c.config, newType) or value > lastOrd(c.config, newType):
-        return nil
-      result = copyNode(n)
-      result.typ() = newType
-      return
-  of nkFloatLit..nkFloat64Lit:
-    if newType.skipTypes(abstractVarRange-{tyTypeDesc}).kind == tyFloat:
-      if not floatRangeCheck(n.floatVal, newType):
-        return nil
-      result = copyNode(n)
-      result.typ() = newType
-      return
-  of nkSym:
-    if n.sym.kind == skEnumField and not sameTypeOrNil(n.sym.typ, newType) and isOrdinalType(newType):
-      let value = n.sym.position
-      if value < firstOrd(c.config, newType) or value > lastOrd(c.config, newType):
-        return nil
-      result = copyNode(n)
-      result.typ() = newType
-      return
-  else: discard
-  return implicitConv(kind, newType, n, m, c)
-
 proc isLValue(c: PContext; n: PNode, isOutParam = false): bool {.inline.} =
   let aa = isAssignable(nil, n)
   case aa
@@ -2305,11 +2220,9 @@ proc userConvMatch(c: PContext, m: var TCandidate, f, a: PType,
       dest = generateTypeInstance(c, m.bindings, arg, dest)
     let fdest = typeRel(m, f, dest)
     if fdest in {isEqual, isGeneric} and not (dest.kind == tyLent and f.kind in {tyVar}):
-      # can't fully mark used yet, may not be used in final call
-      incl(c.converters[i].flags, sfUsed)
-      markOwnerModuleAsUsed(c, c.converters[i])
+      markUsed(c, arg.info, c.converters[i])
       var s = newSymNode(c.converters[i])
-      s.typ() = c.converters[i].typ
+      s.typ = c.converters[i].typ
       s.info = arg.info
       result = newNodeIT(nkHiddenCallConv, arg.info, dest)
       result.add s
@@ -2362,7 +2275,7 @@ proc localConvMatch(c: PContext, m: var TCandidate, f, a: PType,
     if result.kind == nkCall: result.transitionSonsKind(nkHiddenCallConv)
     inc(m.convMatches)
     if r == isGeneric:
-      result.typ() = getInstantiatedType(c, arg, m, base(f))
+      result.typ = getInstantiatedType(c, arg, m, base(f))
     m.baseTypeMatch = true
 
 proc incMatches(m: var TCandidate; r: TTypeRelation; convMatch = 1) =
@@ -2418,7 +2331,7 @@ proc paramTypesMatchAux(m: var TCandidate, f, a: PType,
         let typ = newTypeS(tyStatic, c, son = evaluated.typ)
         typ.n = evaluated
         arg = copyTree(arg) # fix #12864
-        arg.typ() = typ
+        arg.typ = typ
         a = typ
       else:
         if m.callee.kind == tyGenericBody:
@@ -2458,9 +2371,9 @@ proc paramTypesMatchAux(m: var TCandidate, f, a: PType,
     var instantiationCounter = 0
     var lastBindingCount = -1
     while r in {isBothMetaConvertible, isInferred, isInferredConvertible} and
-        lastBindingCount != m.bindings.currentLen and
+        lastBindingCount != m.bindings.len and
         instantiationCounter < 100:
-      lastBindingCount = m.bindings.currentLen
+      lastBindingCount = m.bindings.len
       inc(instantiationCounter)
       if arg.kind in {nkProcDef, nkFuncDef, nkIteratorDef} + nkLambdaKinds:
         result = c.semInferredLambda(c, m.bindings, arg)
@@ -2481,20 +2394,7 @@ proc paramTypesMatchAux(m: var TCandidate, f, a: PType,
     if f.skipTypes({tyRange}).kind in {tyInt, tyUInt}:
       inc(m.convMatches)
     inc(m.convMatches)
-    if skipTypes(f, abstractVar-{tyTypeDesc}).kind == tySet:
-      if tfIsConstructor in a.flags and arg.kind == nkCurly:
-        # we marked the set as convertible only because the arg is a literal
-        # in which case we individually convert each element
-        let t =
-          if containsGenericType(f):
-            getInstantiatedType(c, arg, m, f).skipTypes({tySink})
-          else:
-            f.skipTypes({tySink})
-        result = convertLiteral(nkHiddenStdConv, c, m, arg, t)
-      else:
-        result = nil
-    else:
-      result = implicitConv(nkHiddenStdConv, f, arg, m, c)
+    result = implicitConv(nkHiddenStdConv, f, arg, m, c)
   of isIntConv:
     # I'm too lazy to introduce another ``*matches`` field, so we conflate
     # ``isIntConv`` and ``isIntLit`` here:
@@ -2529,15 +2429,9 @@ proc paramTypesMatchAux(m: var TCandidate, f, a: PType,
       result = arg
     elif skipTypes(arg.typ, abstractVar-{tyTypeDesc}).kind == tyTuple or cmpInheritancePenalty(oldInheritancePenalty, m.inheritancePenalty) > 0:
       result = implicitConv(nkHiddenSubConv, f, arg, m, c)
-    elif arg.typ.isEmptyContainer or
-        # XXX `and not m.isNoCall` is a workaround
-        # passing an int to generic types converts it to the type `int`
-        # but this isn't done for int literal types, so we preserve the type
-        # i.e. works: `type Foo[T] = array[T, int]; var x: Foo[3]` (see t12938, t14193)
-        # doesn't work: `proc foo[T](): array[T, int] = ...; foo[3]()` (see #23204)
-        (arg.typ.isIntLit and not m.isNoCall):
+    elif arg.typ.isEmptyContainer:
       result = arg.copyTree
-      result.typ() = getInstantiatedType(c, arg, m, f).skipTypes({tySink})
+      result.typ = getInstantiatedType(c, arg, m, f)
     else:
       result = arg
   of isBothMetaConvertible:
@@ -2593,7 +2487,7 @@ proc paramTypesMatchAux(m: var TCandidate, f, a: PType,
         of isGeneric:
           inc(m.convMatches)
           result = copyTree(arg)
-          result.typ() = getInstantiatedType(c, arg, m, base(f))
+          result.typ = getInstantiatedType(c, arg, m, base(f))
           m.baseTypeMatch = true
         of isFromIntLit:
           inc(m.intConvMatches, 256)
@@ -2619,7 +2513,7 @@ proc staticAwareTypeRel(m: var TCandidate, f: PType, arg: var PNode): TTypeRelat
     # The ast of the type does not point to the symbol.
     # Without this we will never resolve a `static proc` with overloads
     let copiedNode = copyNode(arg)
-    copiedNode.typ() = exactReplica(copiedNode.typ)
+    copiedNode.typ = exactReplica(copiedNode.typ)
     copiedNode.typ.n = arg
     arg = copiedNode
   typeRel(m, f, arg.typ)
@@ -2674,8 +2568,7 @@ proc paramTypesMatch*(m: var TCandidate, f, a: PType,
 
       for i in 0..<arg.len:
         if arg[i].sym.kind in matchSet:
-          # we can shallow copy the bindings since they won't be used
-          shallowCopyCandidate(z, m)
+          copyCandidate(z, m)
           z.callee = arg[i].typ
           if arg[i].sym.kind == skType and z.callee.kind != tyTypeDesc:
             # creating the symchoice with the type sym having typedesc type
@@ -2731,7 +2624,7 @@ proc setSon(father: PNode, at: int, son: PNode) =
   #  father[i] = newNodeIT(nkEmpty, son.info, getSysType(tyVoid))
 
 # we are allowed to modify the calling node in the 'prepare*' procs:
-proc prepareOperand(c: PContext; formal: PType; a: PNode, newlyTyped: var bool): PNode =
+proc prepareOperand(c: PContext; formal: PType; a: PNode): PNode =
   if formal.kind == tyUntyped and formal.len != 1:
     # {tyTypeDesc, tyUntyped, tyTyped, tyError}:
     # a.typ == nil is valid
@@ -2749,17 +2642,15 @@ proc prepareOperand(c: PContext; formal: PType; a: PNode, newlyTyped: var bool):
                   #elif formal.kind == tyTyped: {efDetermineType, efWantStmt}
                   #else: {efDetermineType}
       result = c.semOperand(c, a, flags)
-    newlyTyped = true
   else:
     result = a
     considerGenSyms(c, result)
     if result.kind != nkHiddenDeref and result.typ.kind in {tyVar, tyLent} and c.matchedConcept == nil:
       result = newDeref(result)
 
-proc prepareOperand(c: PContext; a: PNode, newlyTyped: var bool): PNode =
+proc prepareOperand(c: PContext; a: PNode): PNode =
   if a.typ.isNil:
     result = c.semOperand(c, a, {efDetermineType})
-    newlyTyped = true
   else:
     result = a
     considerGenSyms(c, result)
@@ -2885,10 +2776,8 @@ proc matchesAux(c: PContext, n, nOrig: PNode, m: var TCandidate, marker: var Int
         noMatch()
       m.baseTypeMatch = false
       m.typedescMatched = false
-      var newlyTyped = false
-      n[a][1] = prepareOperand(c, formal.typ, n[a][1], newlyTyped)
-      if newlyTyped: m.newlyTypedOperands.add(a)
-      n[a].typ() = n[a][1].typ
+      n[a][1] = prepareOperand(c, formal.typ, n[a][1])
+      n[a].typ = n[a][1].typ
       arg = paramTypesMatch(m, formal.typ, n[a].typ,
                                 n[a][1], n[a][1])
       m.firstMismatch.kind = kTypeMismatch
@@ -2911,9 +2800,7 @@ proc matchesAux(c: PContext, n, nOrig: PNode, m: var TCandidate, marker: var Int
         if tfVarargs in m.callee.flags:
           # is ok... but don't increment any counters...
           # we have no formal here to snoop at:
-          var newlyTyped = false
-          n[a] = prepareOperand(c, n[a], newlyTyped)
-          if newlyTyped: m.newlyTypedOperands.add(a)
+          n[a] = prepareOperand(c, n[a])
           if skipTypes(n[a].typ, abstractVar-{tyTypeDesc}).kind==tyString:
             m.call.add implicitConv(nkHiddenStdConv,
                   getSysType(c.graph, n[a].info, tyCstring),
@@ -2927,9 +2814,7 @@ proc matchesAux(c: PContext, n, nOrig: PNode, m: var TCandidate, marker: var Int
           m.baseTypeMatch = false
           m.typedescMatched = false
           incl(marker, formal.position)
-          var newlyTyped = false
-          n[a] = prepareOperand(c, formal.typ, n[a], newlyTyped)
-          if newlyTyped: m.newlyTypedOperands.add(a)
+          n[a] = prepareOperand(c, formal.typ, n[a])
           arg = paramTypesMatch(m, formal.typ, n[a].typ,
                                     n[a], nOrig[a])
           if arg != nil and m.baseTypeMatch and container != nil:
@@ -2965,9 +2850,7 @@ proc matchesAux(c: PContext, n, nOrig: PNode, m: var TCandidate, marker: var Int
         else:
           m.baseTypeMatch = false
           m.typedescMatched = false
-          var newlyTyped = false
-          n[a] = prepareOperand(c, formal.typ, n[a], newlyTyped)
-          if newlyTyped: m.newlyTypedOperands.add(a)
+          n[a] = prepareOperand(c, formal.typ, n[a])
           arg = paramTypesMatch(m, formal.typ, n[a].typ,
                                     n[a], nOrig[a])
           if arg == nil:
@@ -3068,7 +2951,7 @@ proc matches*(c: PContext, n, nOrig: PNode, m: var TCandidate) =
             if m.calleeSym != nil: m.calleeSym.detailedInfo else: "")
           typeMismatch(c.config, formal.ast.info, formal.typ, formal.ast.typ, formal.ast)
           popInfoContext(c.config)
-          formal.ast.typ() = errorType(c)
+          formal.ast.typ = errorType(c)
         if nfDefaultRefsParam in formal.ast.flags:
           m.call.flags.incl nfDefaultRefsParam
         var defaultValue = copyTree(formal.ast)
@@ -3077,7 +2960,7 @@ proc matches*(c: PContext, n, nOrig: PNode, m: var TCandidate) =
         # proc foo(x: T = 0.0)
         # foo()
         if {tfImplicitTypeParam, tfGenericTypeParam} * formal.typ.flags != {}:
-          let existing = lookup(m.bindings, formal.typ)
+          let existing = idTableGet(m.bindings, formal.typ)
           if existing == nil or existing.kind == tyTypeDesc:
             # see bug #11600:
             put(m, formal.typ, defaultValue.typ)

compiler/sizealignoffsetimpl.nim

@@ -477,7 +477,7 @@ template foldSizeOf*(conf: ConfigRef; n: PNode; fallback: PNode): PNode =
   if size >= 0:
     let res = newIntNode(nkIntLit, size)
     res.info = node.info
-    res.typ() = node.typ
+    res.typ = node.typ
     res
   else:
     fallback
@@ -491,7 +491,7 @@ template foldAlignOf*(conf: ConfigRef; n: PNode; fallback: PNode): PNode =
   if align >= 0:
     let res = newIntNode(nkIntLit, align)
     res.info = node.info
-    res.typ() = node.typ
+    res.typ = node.typ
     res
   else:
     fallback
@@ -519,7 +519,7 @@ template foldOffsetOf*(conf: ConfigRef; n: PNode; fallback: PNode): PNode =
   if offset >= 0:
     let tmp = newIntNode(nkIntLit, offset)
     tmp.info = node.info
-    tmp.typ() = node.typ
+    tmp.typ = node.typ
     tmp
   else:
     fallback

compiler/spawn.nim

@@ -16,7 +16,7 @@ from trees import getMagic, getRoot
 proc callProc(a: PNode): PNode =
   result = newNodeI(nkCall, a.info)
   result.add a
-  result.typ() = a.typ.returnType
+  result.typ = a.typ.returnType
 
 # we have 4 cases to consider:
 # - a void proc --> nothing to do
@@ -117,7 +117,7 @@ proc castToVoidPointer(g: ModuleGraph, n: PNode, fvField: PNode): PNode =
     result = newNodeI(nkCast, fvField.info)
     result.add newNodeI(nkEmpty, fvField.info)
     result.add fvField
-    result.typ() = ptrType
+    result.typ = ptrType
 
 proc createWrapperProc(g: ModuleGraph; f: PNode; threadParam, argsParam: PSym;
                        varSection, varInit, call, barrier, fv: PNode;
@@ -200,7 +200,7 @@ proc createCastExpr(argsParam: PSym; objType: PType; idgen: IdGenerator): PNode
   result = newNodeI(nkCast, argsParam.info)
   result.add newNodeI(nkEmpty, argsParam.info)
   result.add newSymNode(argsParam)
-  result.typ() = newType(tyPtr, idgen, objType.owner)
+  result.typ = newType(tyPtr, idgen, objType.owner)
   result.typ.rawAddSon(objType)
 
 template checkMagicProcs(g: ModuleGraph, n: PNode, formal: PNode) =
@@ -266,9 +266,9 @@ proc setupArgsForParallelism(g: ModuleGraph; n: PNode; objType: PType;
     if argType.kind in {tyVarargs, tyOpenArray}:
       # important special case: we always create a zero-copy slice:
       let slice = newNodeI(nkCall, n.info, 4)
-      slice.typ() = n.typ
+      slice.typ = n.typ
       slice[0] = newSymNode(createMagic(g, idgen, "slice", mSlice))
-      slice[0].typ() = getSysType(g, n.info, tyInt) # fake type
+      slice[0].typ = getSysType(g, n.info, tyInt) # fake type
       var fieldB = newSym(skField, tmpName, idgen, objType.owner, n.info, g.config.options)
       fieldB.typ = getSysType(g, n.info, tyInt)
       discard objType.addField(fieldB, g.cache, idgen)

compiler/transf.nim

@@ -56,6 +56,7 @@ type
     contSyms, breakSyms: seq[PSym]  # to transform 'continue' and 'break'
     deferDetected, tooEarly: bool
     isIntroducingNewLocalVars: bool  # true if we are in `introducingNewLocalVars` (don't transform yields)
+    inAddr: bool
     flags: TransformFlags
     graph: ModuleGraph
     idgen: IdGenerator
@@ -97,14 +98,17 @@ proc newTemp(c: PTransf, typ: PType, info: TLineInfo): PNode =
   r.typ = typ #skipTypes(typ, {tyGenericInst, tyAlias, tySink})
   incl(r.flags, sfFromGeneric)
   let owner = getCurrOwner(c)
-  result = newSymNode(r)
+  if owner.isIterator and not c.tooEarly and not isDefined(c.graph.config, "nimOptIters"):
+    result = freshVarForClosureIter(c.graph, r, c.idgen, owner)
+  else:
+    result = newSymNode(r)
 
-proc transform(c: PTransf, n: PNode, noConstFold = false): PNode
+proc transform(c: PTransf, n: PNode): PNode
 
-proc transformSons(c: PTransf, n: PNode, noConstFold = false): PNode =
+proc transformSons(c: PTransf, n: PNode): PNode =
   result = newTransNode(n)
   for i in 0..<n.len:
-    result[i] = transform(c, n[i], noConstFold)
+    result[i] = transform(c, n[i])
 
 proc newAsgnStmt(c: PTransf, kind: TNodeKind, le: PNode, ri: PNode; isFirstWrite: bool): PNode =
   result = newTransNode(kind, ri.info, 2)
@@ -173,10 +177,13 @@ proc transformSym(c: PTransf, n: PNode): PNode =
 
 proc freshVar(c: PTransf; v: PSym): PNode =
   let owner = getCurrOwner(c)
-  var newVar = copySym(v, c.idgen)
-  incl(newVar.flags, sfFromGeneric)
-  setOwner(newVar, owner)
-  result = newSymNode(newVar)
+  if owner.isIterator and not c.tooEarly and not isDefined(c.graph.config, "nimOptIters"):
+    result = freshVarForClosureIter(c.graph, v, c.idgen, owner)
+  else:
+    var newVar = copySym(v, c.idgen)
+    incl(newVar.flags, sfFromGeneric)
+    newVar.owner = owner
+    result = newSymNode(newVar)
 
 proc transformVarSection(c: PTransf, v: PNode): PNode =
   result = newTransNode(v)
@@ -356,7 +363,7 @@ proc transformAsgn(c: PTransf, n: PNode): PNode =
     # given tuple type
     newTupleConstr[i] = def[0]
 
-  newTupleConstr.typ() = rhs.typ
+  newTupleConstr.typ = rhs.typ
 
   let asgnNode = newTransNode(nkAsgn, n.info, 2)
   asgnNode[0] = transform(c, n[0])
@@ -474,8 +481,8 @@ proc transformYield(c: PTransf, n: PNode): PNode =
     result.add(introduceNewLocalVars(c, c.transCon.forLoopBody))
     c.isIntroducingNewLocalVars = false
 
-proc transformAddrDeref(c: PTransf, n: PNode, kinds: TNodeKinds, isAddr = false): PNode =
-  result = transformSons(c, n, noConstFold = isAddr)
+proc transformAddrDeref(c: PTransf, n: PNode, kinds: TNodeKinds): PNode =
+  result = transformSons(c, n)
   # inlining of 'var openarray' iterators; bug #19977
   if n.typ.kind != tyOpenArray and (c.graph.config.backend == backendCpp or sfCompileToCpp in c.module.flags): return
   var n = result
@@ -487,9 +494,9 @@ proc transformAddrDeref(c: PTransf, n: PNode, kinds: TNodeKinds, isAddr = false)
       n[0][0] = m[0]
       result = n[0]
       if n.typ.skipTypes(abstractVar).kind != tyOpenArray:
-        result.typ() = n.typ
+        result.typ = n.typ
       elif n.typ.skipTypes(abstractInst).kind in {tyVar}:
-        result.typ() = toVar(result.typ, n.typ.skipTypes(abstractInst).kind, c.idgen)
+        result.typ = toVar(result.typ, n.typ.skipTypes(abstractInst).kind, c.idgen)
   of nkHiddenStdConv, nkHiddenSubConv, nkConv:
     var m = n[0][1]
     if m.kind in kinds:
@@ -497,9 +504,9 @@ proc transformAddrDeref(c: PTransf, n: PNode, kinds: TNodeKinds, isAddr = false)
       n[0][1] = m[0]
       result = n[0]
       if n.typ.skipTypes(abstractVar).kind != tyOpenArray:
-        result.typ() = n.typ
+        result.typ = n.typ
       elif n.typ.skipTypes(abstractInst).kind in {tyVar}:
-        result.typ() = toVar(result.typ, n.typ.skipTypes(abstractInst).kind, c.idgen)
+        result.typ = toVar(result.typ, n.typ.skipTypes(abstractInst).kind, c.idgen)
   else:
     if n[0].kind in kinds and
         not (n[0][0].kind == nkSym and n[0][0].sym.kind == skForVar and
@@ -507,15 +514,13 @@ proc transformAddrDeref(c: PTransf, n: PNode, kinds: TNodeKinds, isAddr = false)
         ) and not (n[0][0].kind == nkSym and n[0][0].sym.kind == skParam and
           n.typ.kind == tyVar and
           n.typ.skipTypes(abstractVar).kind == tyOpenArray and
-          n[0][0].typ.skipTypes(abstractVar).kind == tyString) and
-          not (isAddr and n.typ.kind == tyVar and n[0][0].typ.kind == tyRef and
-              n[0][0].kind == nkObjConstr)
+          n[0][0].typ.skipTypes(abstractVar).kind == tyString)
         : # elimination is harmful to `for tuple unpack` because of newTupleAccess
           # it is also harmful to openArrayLoc (var openArray) for strings
       # addr ( deref ( x )) --> x
       result = n[0][0]
       if n.typ.skipTypes(abstractVar).kind != tyOpenArray:
-        result.typ() = n.typ
+        result.typ = n.typ
 
 proc generateThunk(c: PTransf; prc: PNode, dest: PType): PNode =
   ## Converts 'prc' into '(thunk, nil)' so that it's compatible with
@@ -574,7 +579,7 @@ proc transformConv(c: PTransf, n: PNode): PNode =
     else:
       result = transform(c, n[1])
       #result = transformSons(c, n)
-      result.typ() = takeType(n.typ, n[1].typ, c.graph, c.idgen)
+      result.typ = takeType(n.typ, n[1].typ, c.graph, c.idgen)
       #echo n.info, " came here and produced ", typeToString(result.typ),
       #   " from ", typeToString(n.typ), " and ", typeToString(n[1].typ)
   of tyCstring:
@@ -602,7 +607,7 @@ proc transformConv(c: PTransf, n: PNode): PNode =
         result[0] = transform(c, n[1])
       else:
         result = transform(c, n[1])
-        result.typ() = n.typ
+        result.typ = n.typ
     else:
       result = transformSons(c, n)
   of tyObject:
@@ -615,7 +620,7 @@ proc transformConv(c: PTransf, n: PNode): PNode =
       result[0] = transform(c, n[1])
     else:
       result = transform(c, n[1])
-      result.typ() = n.typ
+      result.typ = n.typ
   of tyGenericParam, tyOrdinal:
     result = transform(c, n[1])
     # happens sometimes for generated assignments, etc.
@@ -639,12 +644,6 @@ proc putArgInto(arg: PNode, formal: PType): TPutArgInto =
     case arg.kind
     of nkStmtListExpr:
       return paComplexOpenarray
-    of nkCall:
-      if skipTypes(arg.typ, abstractInst).kind in {tyOpenArray, tyVarargs}:
-        # XXX incorrect, causes #13417 when `arg` has side effects.
-        return paDirectMapping
-      else:
-        return paComplexOpenarray
     of nkBracket:
       return paFastAsgnTakeTypeFromArg
     else:
@@ -811,7 +810,7 @@ proc transformFor(c: PTransf, n: PNode): PNode =
       stmtList.add(newAsgnStmt(c, nkFastAsgn, temp, addrExp, true))
       newC.mapping[formal.itemId] = newDeref(temp)
     of paComplexOpenarray:
-      # XXX arrays will deep copy here (pretty bad).
+      # arrays will deep copy here (pretty bad).
       var temp = newTemp(c, arg.typ, formal.info)
       addVar(v, temp)
       stmtList.add(newAsgnStmt(c, nkFastAsgn, temp, arg, true))
@@ -841,7 +840,7 @@ proc transformCase(c: PTransf, n: PNode): PNode =
         # as an expr
         let kind = if n.typ != nil: nkIfExpr else: nkIfStmt
         ifs = newTransNode(kind, it.info, 0)
-        ifs.typ() = n.typ
+        ifs.typ = n.typ
       ifs.add(e)
     of nkElse:
       if ifs == nil: result.add(e)
@@ -949,7 +948,7 @@ proc transformExceptBranch(c: PTransf, n: PNode): PNode =
     let convNode = newTransNode(nkHiddenSubConv, n[1].info, 2)
     convNode[0] = newNodeI(nkEmpty, n.info)
     convNode[1] = excCall
-    convNode.typ() = excTypeNode.typ.toRef(c.idgen)
+    convNode.typ = excTypeNode.typ.toRef(c.idgen)
     # -> let exc = ...
     let identDefs = newTransNode(nkIdentDefs, n[1].info, 3)
     identDefs[0] = n[0][2]
@@ -1006,12 +1005,12 @@ proc transformDerefBlock(c: PTransf, n: PNode): PNode =
   # We transform (block: x)[] to (block: x[])
   let e0 = n[0]
   result = shallowCopy(e0)
-  result.typ() = n.typ
+  result.typ = n.typ
   for i in 0 ..< e0.len - 1:
     result[i] = e0[i]
   result[e0.len-1] = newTreeIT(nkHiddenDeref, n.info, n.typ, e0[e0.len-1])
 
-proc transform(c: PTransf, n: PNode, noConstFold = false): PNode =
+proc transform(c: PTransf, n: PNode): PNode =
   when false:
     var oldDeferAnchor: PNode
     if n.kind in {nkElifBranch, nkOfBranch, nkExceptBranch, nkElifExpr,
@@ -1077,8 +1076,13 @@ proc transform(c: PTransf, n: PNode, noConstFold = false): PNode =
   of nkBreakStmt: result = transformBreak(c, n)
   of nkCallKinds:
     result = transformCall(c, n)
-  of nkAddr, nkHiddenAddr:
-    result = transformAddrDeref(c, n, {nkDerefExpr, nkHiddenDeref}, isAddr = true)
+  of nkHiddenAddr:
+    result = transformAddrDeref(c, n, {nkHiddenDeref})
+  of nkAddr:
+    let oldInAddr = c.inAddr
+    c.inAddr = true
+    result = transformAddrDeref(c, n, {nkDerefExpr, nkHiddenDeref})
+    c.inAddr = oldInAddr
   of nkDerefExpr:
     result = transformAddrDeref(c, n, {nkAddr, nkHiddenAddr})
   of nkHiddenDeref:
@@ -1158,7 +1162,7 @@ proc transform(c: PTransf, n: PNode, noConstFold = false): PNode =
   let exprIsPointerCast = n.kind in {nkCast, nkConv, nkHiddenStdConv} and
                           n.typ != nil and
                           n.typ.kind == tyPointer
-  if not exprIsPointerCast and not noConstFold:
+  if not exprIsPointerCast and not c.inAddr:
     var cnst = getConstExpr(c.module, result, c.idgen, c.graph)
     # we inline constants if they are not complex constants:
     if cnst != nil and not dontInlineConstant(n, cnst):
@@ -1208,7 +1212,7 @@ proc liftDeferAux(n: PNode) =
           tryStmt.add deferPart
           n[i] = tryStmt
           n.sons.setLen(i+1)
-          n.typ() = tryStmt.typ
+          n.typ = tryStmt.typ
           goOn = true
           break
   for i in 0..n.safeLen-1:

compiler/trees.nim

@@ -147,13 +147,6 @@ proc whichPragma*(n: PNode): TSpecialWord =
   of nkCast: return wCast
   of nkClosedSymChoice, nkOpenSymChoice:
     return whichPragma(key[0])
-  of nkBracketExpr:
-    if n.kind notin nkPragmaCallKinds: return wInvalid
-    result = whichPragma(key[0])
-    if result notin {wHint, wHintAsError, wWarning, wWarningAsError}:
-      # note bracket pragmas, see processNote
-      result = wInvalid
-    return
   else: return wInvalid
   if result in nonPragmaWordsLow..nonPragmaWordsHigh:
     result = wInvalid

compiler/types.nim

@@ -1250,18 +1250,18 @@ proc sameTypeAux(x, y: PType, c: var TSameTypeClosure): bool =
     b = skipTypes(b.last, aliasSkipSet)
   assert(a != nil)
   assert(b != nil)
-  case c.cmp
-  of dcEq:
-    if a.kind != b.kind: return false
-  of dcEqIgnoreDistinct:
-    let distinctSkipSet = maybeSkipRange({tyDistinct, tyGenericInst})
-    a = a.skipTypes(distinctSkipSet)
-    b = b.skipTypes(distinctSkipSet)
-    if a.kind != b.kind: return false
-  of dcEqOrDistinctOf:
-    let distinctSkipSet = maybeSkipRange({tyDistinct, tyGenericInst})
-    a = a.skipTypes(distinctSkipSet)
-    if a.kind != b.kind: return false
+  if a.kind != b.kind:
+    case c.cmp
+    of dcEq: return false
+    of dcEqIgnoreDistinct:
+      let distinctSkipSet = maybeSkipRange({tyDistinct, tyGenericInst})
+      a = a.skipTypes(distinctSkipSet)
+      b = b.skipTypes(distinctSkipSet)
+      if a.kind != b.kind: return false
+    of dcEqOrDistinctOf:
+      let distinctSkipSet = maybeSkipRange({tyDistinct, tyGenericInst})
+      a = a.skipTypes(distinctSkipSet)
+      if a.kind != b.kind: return false
 
   #[
     The following code should not run in the case either side is an generic alias,
@@ -1269,8 +1269,7 @@ proc sameTypeAux(x, y: PType, c: var TSameTypeClosure): bool =
     objects ie `type A[T] = SomeObject`
   ]#
   # this is required by tunique_type but makes no sense really:
-  if c.cmp == dcEq and x.kind == tyGenericInst and
-      IgnoreTupleFields notin c.flags and tyDistinct != y.kind:
+  if x.kind == tyGenericInst and IgnoreTupleFields notin c.flags and tyDistinct != y.kind:
     let
       lhs = x.skipGenericAlias
       rhs = y.skipGenericAlias
@@ -1685,7 +1684,7 @@ proc skipHidden*(n: PNode): PNode =
 
 proc skipConvTakeType*(n: PNode): PNode =
   result = n.skipConv
-  result.typ() = n.typ
+  result.typ = n.typ
 
 proc isEmptyContainer*(t: PType): bool =
   case t.kind
@@ -1725,7 +1724,7 @@ proc skipHiddenSubConv*(n: PNode; g: ModuleGraph; idgen: IdGenerator): PNode =
       result = n
     else:
       result = copyTree(result)
-      result.typ() = dest
+      result.typ = dest
   else:
     result = n
 
@@ -1935,66 +1934,3 @@ proc isCharArrayPtr*(t: PType; allowPointerToChar: bool): bool =
       result = false
   else:
     result = false
-
-proc nominalRoot*(t: PType): PType =
-  ## the "name" type of a given instance of a nominal type,
-  ## i.e. the type directly associated with the symbol where the root
-  ## nominal type of `t` was defined, skipping things like generic instances,
-  ## aliases, `var`/`sink`/`typedesc` modifiers
-  ## 
-  ## instead of returning the uninstantiated body of a generic type,
-  ## returns the type of the symbol instead (with tyGenericBody type)
-  result = nil
-  case t.kind
-  of tyAlias, tyVar, tySink:
-    # varargs?
-    result = nominalRoot(t.skipModifier)
-  of tyTypeDesc:
-    # for proc foo(_: type T)
-    result = nominalRoot(t.skipModifier)
-  of tyGenericInvocation, tyGenericInst:
-    result = t
-    # skip aliases, so this works in the same module but not in another module:
-    # type Foo[T] = object
-    # type Bar[T] = Foo[T]
-    # proc foo[T](x: Bar[T]) = ... # attached to type
-    while result.skipModifier.kind in {tyGenericInvocation, tyGenericInst}:
-      result = result.skipModifier
-    result = nominalRoot(result[0])
-  of tyGenericBody:
-    result = t
-    # this time skip the aliases but take the generic body
-    while result.skipModifier.kind in {tyGenericInvocation, tyGenericInst}:
-      result = result.skipModifier[0]
-    let val = result.skipModifier
-    if val.kind in {tyDistinct, tyEnum, tyObject} or
-        (val.kind in {tyRef, tyPtr} and tfRefsAnonObj in val.flags):
-      # atomic nominal types, this generic body is attached to them
-      discard
-    else:
-      result = nominalRoot(val)
-  of tyCompositeTypeClass:
-    # parameter with type Foo
-    result = nominalRoot(t.skipModifier)
-  of tyGenericParam:
-    if t.genericParamHasConstraints:
-      # T: Foo
-      result = nominalRoot(t.genericConstraint)
-    else:
-      result = nil
-  of tyDistinct, tyEnum, tyObject:
-    result = t
-  of tyPtr, tyRef:
-    if tfRefsAnonObj in t.flags:
-      # in the case that we have `type Foo = ref object` etc
-      result = t
-    else:
-      # we could allow this in general, but there's things like `seq[Foo]`
-      #result = nominalRoot(t.skipModifier)
-      result = nil
-  of tyStatic:
-    result = nominalRoot(t.base)
-  else:
-    # skips all typeclasses
-    # is this correct for `concept`?
-    result = nil

compiler/vm.nim

@@ -202,7 +202,7 @@ proc copyValue(src: PNode): PNode =
     return src
   result = newNode(src.kind)
   result.info = src.info
-  result.typ() = src.typ
+  result.typ = src.typ
   result.flags = src.flags * PersistentNodeFlags
   result.comment = src.comment
   when defined(useNodeIds):
@@ -1276,11 +1276,6 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       createSet(regs[ra])
       move(regs[ra].node.sons,
            nimsets.diffSets(c.config, regs[rb].node, regs[rc].node).sons)
-    of opcXorSet:
-      decodeBC(rkNode)
-      createSet(regs[ra])
-      move(regs[ra].node.sons,
-           nimsets.symdiffSets(c.config, regs[rb].node, regs[rc].node).sons)
     of opcConcatStr:
       decodeBC(rkNode)
       createStr regs[ra]
@@ -1537,10 +1532,10 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       # Set the `name` field of the exception
       var exceptionNameNode = newStrNode(nkStrLit, c.currentExceptionA.typ.sym.name.s)
       if c.currentExceptionA[2].kind == nkExprColonExpr:
-        exceptionNameNode.typ() = c.currentExceptionA[2][1].typ
+        exceptionNameNode.typ = c.currentExceptionA[2][1].typ
         c.currentExceptionA[2][1] = exceptionNameNode
       else:
-        exceptionNameNode.typ() = c.currentExceptionA[2].typ
+        exceptionNameNode.typ = c.currentExceptionA[2].typ
         c.currentExceptionA[2] = exceptionNameNode
       c.exceptionInstr = pc
 
@@ -1582,7 +1577,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       let instr2 = c.code[pc]
       let count = regs[instr2.regA].intVal.int
       regs[ra].node = newNodeI(nkBracket, c.debug[pc])
-      regs[ra].node.typ() = typ
+      regs[ra].node.typ = typ
       newSeq(regs[ra].node.sons, count)
       for i in 0..<count:
         regs[ra].node[i] = getNullValue(c, typ.elementType, c.debug[pc], c.config)
@@ -1997,7 +1992,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       else:
         internalAssert c.config, false
       regs[ra].node.info = n.info
-      regs[ra].node.typ() = n.typ
+      regs[ra].node.typ = n.typ
     of opcNCopyLineInfo:
       decodeB(rkNode)
       regs[ra].node.info = regs[rb].node.info
@@ -2077,7 +2072,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
         ensureKind(rkNode)
         regs[ra].node = temp
         regs[ra].node.info = c.debug[pc]
-      regs[ra].node.typ() = typ
+      regs[ra].node.typ = typ
     of opcConv:
       let rb = instr.regB
       inc pc
@@ -2337,17 +2332,9 @@ proc execProc*(c: PCtx; sym: PSym; args: openArray[PNode]): PNode =
     localError(c.config, sym.info,
       "NimScript: attempt to call non-routine: " & sym.name.s)
 
-proc errorNode(idgen: IdGenerator; owner: PSym, n: PNode): PNode =
-  result = newNodeI(nkEmpty, n.info)
-  result.typ() = newType(tyError, idgen, owner)
-  result.typ.flags.incl tfCheckedForDestructor
-
 proc evalStmt*(c: PCtx, n: PNode) =
   let n = transformExpr(c.graph, c.idgen, c.module, n)
   let start = genStmt(c, n)
-  if c.cannotEval:
-    c.cannotEval = false
-    return
   # execute new instructions; this redundant opcEof check saves us lots
   # of allocations in 'execute':
   if c.code[start].opcode != opcEof:
@@ -2358,10 +2345,7 @@ proc evalExpr*(c: PCtx, n: PNode): PNode =
   # `nim --eval:"expr"` might've used it at some point for idetools; could
   # be revived for nimsuggest
   let n = transformExpr(c.graph, c.idgen, c.module, n)
-  c.cannotEval = false
   let start = genExpr(c, n)
-  if c.cannotEval:
-    return errorNode(c.idgen, c.module, n)
   assert c.code[start].opcode != opcEof
   result = execute(c, start)
 
@@ -2414,10 +2398,7 @@ proc evalConstExprAux(module: PSym; idgen: IdGenerator;
   var c = PCtx g.vm
   let oldMode = c.mode
   c.mode = mode
-  c.cannotEval = false
   let start = genExpr(c, n, requiresValue = mode!=emStaticStmt)
-  if c.cannotEval:
-    return errorNode(idgen, prc, n)
   if c.code[start].opcode == opcEof: return newNodeI(nkEmpty, n.info)
   assert c.code[start].opcode != opcEof
   when debugEchoCode: c.echoCode start
@@ -2474,7 +2455,7 @@ proc setupMacroParam(x: PNode, typ: PType): TFullReg =
     var n = x
     if n.kind in {nkHiddenSubConv, nkHiddenStdConv}: n = n[1]
     n.flags.incl nfIsRef
-    n.typ() = x.typ
+    n.typ = x.typ
     result = TFullReg(kind: rkNode, node: n)
 
 iterator genericParamsInMacroCall*(macroSym: PSym, call: PNode): (PSym, PNode) =
@@ -2488,6 +2469,11 @@ iterator genericParamsInMacroCall*(macroSym: PSym, call: PNode): (PSym, PNode) =
 # to prevent endless recursion in macro instantiation
 const evalMacroLimit = 1000
 
+#proc errorNode(idgen: IdGenerator; owner: PSym, n: PNode): PNode =
+#  result = newNodeI(nkEmpty, n.info)
+#  result.typ = newType(tyError, idgen, owner)
+#  result.typ.flags.incl tfCheckedForDestructor
+
 proc evalMacroCall*(module: PSym; idgen: IdGenerator; g: ModuleGraph; templInstCounter: ref int;
                     n, nOrig: PNode, sym: PSym): PNode =
   #if g.config.errorCounter > 0: return errorNode(idgen, module, n)
@@ -2511,10 +2497,7 @@ proc evalMacroCall*(module: PSym; idgen: IdGenerator; g: ModuleGraph; templInstC
   c.comesFromHeuristic.line = 0'u16
   c.callsite = nOrig
   c.templInstCounter = templInstCounter
-  c.cannotEval = false
   let start = genProc(c, sym)
-  if c.cannotEval:
-    return errorNode(idgen, module, n)
 
   var tos = PStackFrame(prc: sym, comesFrom: 0, next: nil)
   let maxSlots = sym.offset

compiler/vmdef.nim

@@ -100,7 +100,7 @@ type
     opcEqRef, opcEqNimNode, opcSameNodeType,
     opcXor, opcNot, opcUnaryMinusInt, opcUnaryMinusFloat, opcBitnotInt,
     opcEqStr, opcEqCString, opcLeStr, opcLtStr, opcEqSet, opcLeSet, opcLtSet,
-    opcMulSet, opcPlusSet, opcMinusSet, opcXorSet, opcConcatStr,
+    opcMulSet, opcPlusSet, opcMinusSet, opcConcatStr,
     opcContainsSet, opcRepr, opcSetLenStr, opcSetLenSeq,
     opcIsNil, opcOf, opcIs,
     opcParseFloat, opcConv, opcCast,
@@ -270,7 +270,6 @@ type
     templInstCounter*: ref int # gives every template instantiation a unique ID, needed here for getAst
     vmstateDiff*: seq[(PSym, PNode)] # we remember the "diff" to global state here (feature for IC)
     procToCodePos*: Table[int, int]
-    cannotEval*: bool
 
   PStackFrame* = ref TStackFrame
   TStackFrame* {.acyclic.} = object

compiler/vmdeps.nim

@@ -35,7 +35,7 @@ proc atomicTypeX(cache: IdentCache; name: string; m: TMagic; t: PType; info: TLi
   sym.magic = m
   sym.typ = t
   result = newSymNode(sym)
-  result.typ() = t
+  result.typ = t
 
 proc atomicTypeX(s: PSym; info: TLineInfo): PNode =
   result = newSymNode(s)
@@ -52,7 +52,7 @@ proc mapTypeToBracketX(cache: IdentCache; name: string; m: TMagic; t: PType; inf
   for a in t.kids:
     if a == nil:
       let voidt = atomicTypeX(cache, "void", mVoid, t, info, idgen)
-      voidt.typ() = newType(tyVoid, idgen, t.owner)
+      voidt.typ = newType(tyVoid, idgen, t.owner)
       result.add voidt
     else:
       result.add mapTypeToAstX(cache, a, info, idgen, inst)
@@ -136,7 +136,7 @@ proc mapTypeToAstX(cache: IdentCache; t: PType; info: TLineInfo;
       if allowRecursion:
         result = mapTypeToAstR(t.skipModifier, info)
         # keep original type info for getType calls on the output node:
-        result.typ() = t
+        result.typ = t
       else:
         result = newNodeX(nkBracketExpr)
         #result.add mapTypeToAst(t.last, info)
@@ -146,7 +146,7 @@ proc mapTypeToAstX(cache: IdentCache; t: PType; info: TLineInfo;
     else:
       result = mapTypeToAstX(cache, t.skipModifier, info, idgen, inst, allowRecursion)
       # keep original type info for getType calls on the output node:
-      result.typ() = t
+      result.typ = t
   of tyGenericBody:
     if inst:
       result = mapTypeToAstR(t.typeBodyImpl, info)
@@ -237,7 +237,7 @@ proc mapTypeToAstX(cache: IdentCache; t: PType; info: TLineInfo;
   of tySequence: result = mapTypeToBracket("seq", mSeq, t, info)
   of tyProc:
     if inst:
-      result = newNodeX(if tfIterator in t.flags: nkIteratorTy else: nkProcTy)
+      result = newNodeX(nkProcTy)
       var fp = newNodeX(nkFormalParams)
       if t.returnType == nil:
         fp.add newNodeI(nkEmpty, info)
@@ -246,15 +246,8 @@ proc mapTypeToAstX(cache: IdentCache; t: PType; info: TLineInfo;
       for i in FirstParamAt..<t.kidsLen:
         fp.add newIdentDefs(t.n[i], t[i])
       result.add fp
-      var prag =
-        if t.n[0].len > 0:
-          t.n[0][pragmasEffects].copyTree
-        else:
-          newNodeI(nkEmpty, info)
-      if t.callConv != ccClosure or tfExplicitCallConv in t.flags:
-        if prag.kind == nkEmpty: prag = newNodeI(nkPragma, info)
-        prag.add newIdentNode(getIdent(cache, $t.callConv), info)
-      result.add prag
+      result.add if t.n[0].len > 0: t.n[0][pragmasEffects].copyTree
+                 else: newNodeI(nkEmpty, info)
     else:
       result = mapTypeToBracket("proc", mNone, t, info)
   of tyOpenArray: result = mapTypeToBracket("openArray", mOpenArray, t, info)

compiler/vmgen.nim

@@ -53,7 +53,6 @@ type
     gfNode # Affects how variables are loaded - always loads as rkNode
     gfNodeAddr # Affects how variables are loaded - always loads as rkNodeAddr
     gfIsParam # do not deepcopy parameters, they are immutable
-    gfIsSinkParam # deepcopy sink parameters
   TGenFlags = set[TGenFlag]
 
 proc debugInfo(c: PCtx; info: TLineInfo): string =
@@ -621,17 +620,10 @@ proc genCall(c: PCtx; n: PNode; dest: var TDest) =
   let fntyp = skipTypes(n[0].typ, abstractInst)
   for i in 0..<n.len:
     var r: TRegister = x+i
+    c.gen(n[i], r, {gfIsParam})
     if i >= fntyp.signatureLen:
-      c.gen(n[i], r, {gfIsParam})
       internalAssert c.config, tfVarargs in fntyp.flags
       c.gABx(n, opcSetType, r, c.genType(n[i].typ))
-    else:
-      if fntyp[i] != nil and fntyp[i].kind == tySink and
-          fntyp[i].skipTypes({tySink}).kind in {tyObject, tyString, tySequence}:
-        c.gen(n[i], r, {gfIsSinkParam})
-      else:
-        c.gen(n[i], r, {gfIsParam})
-
   if dest < 0:
     c.gABC(n, opcIndCall, 0, x, n.len)
   else:
@@ -1212,7 +1204,6 @@ proc genMagic(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags = {}, m: TMag
   of mMulSet: genBinarySet(c, n, dest, opcMulSet)
   of mPlusSet: genBinarySet(c, n, dest, opcPlusSet)
   of mMinusSet: genBinarySet(c, n, dest, opcMinusSet)
-  of mXorSet: genBinarySet(c, n, dest, opcXorSet)
   of mConStrStr: genVarargsABC(c, n, dest, opcConcatStr)
   of mInSet: genBinarySet(c, n, dest, opcContainsSet)
   of mRepr: genUnaryABC(c, n, dest, opcRepr)
@@ -1474,9 +1465,9 @@ proc canElimAddr(n: PNode; idgen: IdGenerator): PNode =
       result = copyNode(n[0])
       result.add m[0]
       if n.typ.skipTypes(abstractVar).kind != tyOpenArray:
-        result.typ() = n.typ
+        result.typ = n.typ
       elif n.typ.skipTypes(abstractInst).kind in {tyVar}:
-        result.typ() = toVar(result.typ, n.typ.skipTypes(abstractInst).kind, idgen)
+        result.typ = toVar(result.typ, n.typ.skipTypes(abstractInst).kind, idgen)
   of nkHiddenStdConv, nkHiddenSubConv, nkConv:
     var m = n[0][1]
     if m.kind in {nkDerefExpr, nkHiddenDeref}:
@@ -1485,9 +1476,9 @@ proc canElimAddr(n: PNode; idgen: IdGenerator): PNode =
       result.add n[0][0]
       result.add m[0]
       if n.typ.skipTypes(abstractVar).kind != tyOpenArray:
-        result.typ() = n.typ
+        result.typ = n.typ
       elif n.typ.skipTypes(abstractInst).kind in {tyVar}:
-        result.typ() = toVar(result.typ, n.typ.skipTypes(abstractInst).kind, idgen)
+        result.typ = toVar(result.typ, n.typ.skipTypes(abstractInst).kind, idgen)
   else:
     if n[0].kind in {nkDerefExpr, nkHiddenDeref}:
       # addr ( deref ( x )) --> x
@@ -1543,12 +1534,9 @@ proc setSlot(c: PCtx; v: PSym) =
     v.position = getFreeRegister(c, if v.kind == skLet: slotFixedLet else: slotFixedVar, start = 1)
 
 template cannotEval(c: PCtx; n: PNode) =
-  if c.config.cmd == cmdCheck and c.config.m.errorOutputs != {}:
-    # nim check command with no error outputs doesn't need to cascade here,
-    # includes `tryConstExpr` case which should not continue generating code
+  if c.config.cmd == cmdCheck:
     localError(c.config, n.info, "cannot evaluate at compile time: " & 
     n.renderTree)
-    c.cannotEval = true
     return
   globalError(c.config, n.info, "cannot evaluate at compile time: " &
     n.renderTree)
@@ -1682,7 +1670,7 @@ proc genAsgn(c: PCtx; le, ri: PNode; requiresCopy: bool) =
 
 proc genTypeLit(c: PCtx; t: PType; dest: var TDest) =
   var n = newNode(nkType)
-  n.typ() = t
+  n.typ = t
   genLit(c, n, dest)
 
 proc isEmptyBody(n: PNode): bool =
@@ -1752,8 +1740,6 @@ proc genRdVar(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags) =
         c.gABx(n, opcLdGlobalAddr, dest, s.position)
     elif isImportcVar:
       c.gABx(n, opcLdGlobalDerefFFI, dest, s.position)
-    elif gfIsSinkParam in flags:
-      genAsgn(c, dest, n, requiresCopy = true)
     elif fitsRegister(s.typ) and gfNode notin flags:
       var cc = c.getTemp(n.typ)
       c.gABx(n, opcLdGlobal, cc, s.position)
@@ -1851,7 +1837,7 @@ proc genCheckedObjAccessAux(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags
   let fieldName = $accessExpr[1]
   let msg = genFieldDefect(c.config, fieldName, disc.sym)
   let strLit = newStrNode(msg, accessExpr[1].info)
-  strLit.typ() = strType
+  strLit.typ = strType
   c.genLit(strLit, msgReg)
   c.gABC(n, opcInvalidField, msgReg, discVal)
   c.freeTemp(discVal)

compiler/vtables.nim

@@ -33,13 +33,13 @@ proc dispatch(x: Base, params: ...) =
     dispatchObject,
     newIntNode(nkIntLit, index)
   )
-  getVTableCall.typ() = base.typ
+  getVTableCall.typ = base.typ
   var vTableCall = newNodeIT(nkCall, base.info, base.typ.returnType)
   var castNode = newTree(nkCast,
         newNodeIT(nkType, base.info, base.typ),
         getVTableCall)
 
-  castNode.typ() = base.typ
+  castNode.typ = base.typ
   vTableCall.add castNode
   for col in 1..<paramLen:
     let param = base.typ.n[col].sym

copying.txt

@@ -21,4 +21,4 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
-[ MIT license: https://www.opensource.org/licenses/mit-license.php ]
+[ MIT license: http://www.opensource.org/licenses/mit-license.php ]

doc/backends.md

@@ -31,7 +31,7 @@ Objective-C targets and the JavaScript target. [The C like targets](
 into a library or a final executable. [The JavaScript target](
 #backends-the-javascript-target) can generate a ``.js`` file which you
 reference from an HTML file or create a [standalone Node.js program](
-https://nodejs.org).
+http://nodejs.org).
 
 On top of generating libraries or standalone applications, Nim offers
 bidirectional interfacing with the backend targets through generic and
@@ -87,19 +87,20 @@ available. This includes:
 * OS-specific operations
 * threading, coroutines
 * some modules of the standard library
+* proper 64-bit integer arithmetic
 
 To compensate, the standard library has modules [catered to the JS backend](
-lib.html#pure-libraries-modules-for-the-javascript-backend)
+lib.html#pure-libraries-modules-for-js-backend)
 and more support will come in the future (for instance, Node.js bindings
 to get OS info).
 
 To compile a Nim module into a ``.js`` file use the `js`:option: command; the
 default is a ``.js`` file that is supposed to be referenced in an ``.html``
 file. However, you can also run the code with `nodejs`:idx:
-(https://nodejs.org):
+(http://nodejs.org):
 
   ```cmd
-  nim js -r examples/hallo.nim
+  nim js -d:nodejs -r examples/hallo.nim
   ```
 
 If you experience errors saying that `globalThis` is not defined, be

doc/docgen.md

@@ -67,7 +67,7 @@ Documentation Comments
 
 Any comments which are preceded by a double-hash (`##`), are interpreted as
 documentation.  Comments are parsed as RST (see [reference](
-https://docutils.sourceforge.net/docs/user/rst/quickref.html)), providing
+http://docutils.sourceforge.net/docs/user/rst/quickref.html)), providing
 Nim module authors the ability to easily generate richly formatted
 documentation with only their well-documented code!
 Basic Markdown syntax is also supported inside the doc comments.

doc/hcr.md

@@ -241,5 +241,5 @@ JavaScript target
 =================
 
 Once your code is compiled for hot reloading, a convenient solution for implementing the actual reloading
-in the browser using a framework such as [LiveReload](https://livereload.com/)
+in the browser using a framework such as [LiveReload](http://livereload.com/)
 or [BrowserSync](https://browsersync.io/).

doc/manual.md

@@ -2241,10 +2241,6 @@ Nim supports these `calling conventions`:idx:\:
     only a hint for the compiler: it may completely ignore it, and
     it may inline procedures that are not marked as `inline`.
 
-`noinline`:idx:
-:   The backend compiler may inline procedures that are not marked as `inline`.
-    The noinline convention prevents it.
-
 `fastcall`:idx:
 :   Fastcall means different things to different C compilers. One gets whatever
     the C `__fastcall` means.
@@ -2627,12 +2623,12 @@ In a call `p(args)` where `p` may refer to more than one
 candidate, it is said to be a symbol choice. Overload resolution will attempt to
 find the best candidate, thus transforming the symbol choice into a resolved symbol.
 The routine `p` that matches best is selected following a series of trials explained below. 
-In order: Category matching, Hierarchical Order Comparison, and finally, Complexity Analysis.
+In order: Catagory matching, Hierarchical Order Comparison, and finally, Complexity Analysis.
 
 If multiple candidates match equally well after all trials have been tested, the ambiguity 
 is reported during semantic analysis.
 
-First Trial: Category matching
+First Trial: Catagory matching
 --------------------------------
 
 Every arg in `args` needs to match and there are multiple different categories of matches.
@@ -2693,7 +2689,7 @@ Matching formals for this type include `T`, `object`, `A`, `A[...]` and `A[C]` w
 is a generic typeclass composition and `T` is an unconstrained generic type variable. This list is in order of 
 specificity with respect to `A` as each subsequent category narrows the set of types that are members of their match set.
 
-In this trial, the formal parameters of candidates are compared in order (1st parameter, 2nd parameter, etc.) to search for
+In this trail, the formal parameters of candidates are compared in order (1st parameter, 2nd parameter, etc.) to search for
 a candidate that has an unrivaled specificity. If such a formal parameter is found, the candidate it belongs to is chosen 
 as the resolved symbol.
 
@@ -5173,7 +5169,7 @@ It is possible to raise/catch imported C++ exceptions. Types imported using
 `importcpp` can be raised or caught. Exceptions are raised by value and
 caught by reference. Example:
 
-  ```nim
+  ```nim  test = "nim cpp -r $1"
   type
     CStdException {.importcpp: "std::exception", header: "<exception>", inheritable.} = object
       ## does not inherit from `RootObj`, so we use `inheritable` instead
@@ -8650,14 +8646,6 @@ pragma should be used in addition to the `exportc` pragma. See
 [Dynlib pragma for export].
 
 
-Exportcpp pragma
-----------------
-The `exportcpp` pragma works like the `exportc` pragma but it requires the `cpp` backend.
-When compiled with the `cpp` backend, the `exportc` pragma adds `export "C"` to
-the declaration in the generated code so that it can be called from both C and
-C++ code. `exportcpp` pragma doesn't add `export "C"`.
-
-
 Extern pragma
 -------------
 Like `exportc` or `importc`, the `extern` pragma affects name

doc/manual_experimental.md

@@ -2667,114 +2667,3 @@ proc nothing() =
 ```
 
 The current C(C++) backend implementation cannot generate code for gcc and for vcc at the same time. For example, `{.asmSyntax: "vcc".}` with the ICC compiler will not generate code with intel asm syntax, even though ICC can use both gcc-like and vcc-like asm.
-
-Type-bound overloads
-====================
-
-With the experimental option `--experimental:typeBoundOps`, each "root"
-nominal type (namely `object`, `enum`, `distinct`, direct `Foo = ref object`
-types as well as their generic versions) can have operations attached to it.
-Exported top-level routines declared in the same scope as a nominal type
-with a parameter having a type directly deriving from that nominal type (i.e.
-with `var`/`sink`/`typedesc` modifiers or being in a generic constraint)
-are considered "attached" to the respective nominal type.
-This applies to every parameter regardless of placement.
-
-When a call to a symbol is openly overloaded and overload matching starts,
-for all arguments in the call that have already undergone type checking,
-routines with the same name attached to the root nominal type (if it exists)
-of each given argument are added as a candidate to the overload match.
-This also happens as arguments gradually get typed after every match to an overload.
-This is so that the only overloads considered out of scope are
-attached to the types of the given arguments, and that matches to
-`untyped` or missing parameters are not influenced by outside overloads.
-
-If no overloads with a given name are in scope, then overload matching
-will not begin, and so type-bound overloads are not considered for that name.
-Similarly, if the only overloads with a given name require a parameter to be
-`untyped` or missing, then type-bound overloads will not be considered for
-the argument in that position.
-Generally this means that a "base" overload with a compliant signature should
-be in scope so that type-bound overloads can be used.
-
-In the case of ambiguity between distinct local/imported and type-bound symbols
-in overload matching, type-bound symbols are considered as a less specific
-scope than imports.
-
-An example with the `hash` interface in the standard library is as follows:
-
-```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))
-
-# here both `==` and `hash` are attached to Obj
-# 1. they are both exported
-# 2. they are in the same scope as Obj
-# 3. they have parameters with types directly deriving from Obj
-# 4. Obj is nominal
-```
-
-```nim
-# main.nim
-{.experimental: "typeBoundOps".}
-from objs import Obj # objs.hash, objs.`==` not imported
-import std/tables
-# tables use `hash`, only using the overloads in `std/hashes` and
-# the ones in instantiation scope (in this case, there are none)
-
-var t: Table[Obj, int]
-# because tables use `hash` and `==` in a compliant way,
-# the overloads bound to Obj are also considered, and in this case match best
-t[Obj(x: 3, y: 4, z: "debug")] = 34
-# if `hash` for all objects as in `std/hashes` was used, this would error: 
-echo t[Obj(x: 3, y: 4, z: "ignored")] # 34
-```
-
-Another example, this time with `$` and indirect imports:
-
-```nim
-# foo.nim
-type Foo* = object
-  x*, y*: int
-
-proc `$`*(f: Foo): string =
-  "Foo(" & $f.x & ", " & $f.y & ")"
-```
-
-```nim
-# bar.nim
-import foo
-
-proc makeFoo*(x, y: int): Foo =
-  Foo(x: x, y: y)
-
-proc useFoo*(f: Foo) =
-  echo "used: ", f # directly calls `foo.$` from scope
-```
-
-```nim
-# debugger.nim
-proc debug*[T](obj: T) =
-  echo "debugging: ", obj # calls generic `$`
-```
-
-```nim
-# main.nim
-{.experimental: "typeBoundOps".}
-import bar, debugger # `foo` not imported, so `foo.$` not in scope
-
-let f = makeFoo(123, 456)
-useFoo(f) # used: Foo(123, 456)
-debug(f) # debugging: Foo(123, 456)
-```

doc/nep1.md

@@ -21,7 +21,7 @@ library should follow.
 Note that there can be exceptions to these rules. Nim being as flexible as it
 is, there will be parts of this style guide that don't make sense in certain
 contexts. Furthermore, just as
-[Python's style guide](https://legacy.python.org/dev/peps/pep-0008/) changes
+[Python's style guide](http://legacy.python.org/dev/peps/pep-0008/) changes
 over time, this style guide will too.
 
 These rules will only be enforced for contributions to the Nim

doc/nimc.md

@@ -24,7 +24,7 @@ on the different supported platforms. It is not a definition of the Nim
 programming language (which is covered in the [manual](manual.html)).
 
 Nim is free software; it is licensed under the
-[MIT License](https://www.opensource.org/licenses/mit-license.php).
+[MIT License](http://www.opensource.org/licenses/mit-license.php).
 
 
 Compiler Usage

doc/niminst.md

@@ -14,7 +14,7 @@ Introduction
 
 niminst is a tool to generate an installer for a Nim program. Currently
 it can create an installer for Windows
-via [Inno Setup](https://www.jrsoftware.org/isinfo.php) as well as
+via [Inno Setup](http://www.jrsoftware.org/isinfo.php) as well as
 installation/deinstallation scripts for UNIX. Later versions will support
 Linux' package management systems.
 

doc/regexprs.txt

@@ -41,7 +41,7 @@ Regular expression syntax and semantics
 =======================================
 
 As the regular expressions supported by this module are enormous,
-the reader is referred to https://perldoc.perl.org/perlre.html for the
+the reader is referred to http://perldoc.perl.org/perlre.html for the
 full documentation of Perl's regular expressions.
 
 Because the backslash ``\`` is a meta character both in the Nim

doc/tut1.md

@@ -1182,9 +1182,6 @@ at runtime by 0, the second by 1, and so on. For example:
 
   var x = south     # `x` is of type `Direction`; its value is `south`
   echo x            # prints "south"
-
-  if x == Direction.south:
-    echo "It's south!"
   ```
 
 All the comparison operators can be used with enumeration types.

koch.nim

@@ -11,7 +11,7 @@
 
 const
   # examples of possible values for repos: Head, ea82b54
-  NimbleStableCommit = "46e2ae13eeb95619a371a74d16efc5aff30ea371" # 0.16.2
+  NimbleStableCommit = "4fb6f8e6c33963f6f510fe82d09ad2a61b5e4265" # 0.16.1
   AtlasStableCommit = "5faec3e9a33afe99a7d22377dd1b45a5391f5504"
   ChecksumsStableCommit = "bd9bf4eaea124bf8d01e08f92ac1b14c6879d8d3"
   SatStableCommit = "faf1617f44d7632ee9601ebc13887644925dcc01"
@@ -345,7 +345,8 @@ proc boot(args: string, skipIntegrityCheck: bool) =
   let smartNimcache = (if "release" in args or "danger" in args: "nimcache/r_" else: "nimcache/d_") &
                       hostOS & "_" & hostCPU
 
-  bundleChecksums(false)
+  if not dirExists("dist/checksums"):
+    bundleChecksums(false)
 
   let usingLibFFI = "nimHasLibFFI" in args
   if usingLibFFI and not dirExists("dist/libffi"):
@@ -508,7 +509,8 @@ proc temp(args: string) =
       result[1].add " " & quoteShell(args[i])
       inc i
 
-  bundleChecksums(false)
+  if not dirExists("dist/checksums"):
+    bundleChecksums(false)
 
   let d = getAppDir()
   let output = d / "compiler" / "nim".exe

lib/experimental/diff.nim

@@ -10,7 +10,7 @@
 ## This module implements an algorithm to compute the
 ## `diff`:idx: between two sequences of lines.
 ##
-## - To learn more see `Diff on Wikipedia. <https://wikipedia.org/wiki/Diff>`_
+## - To learn more see `Diff on Wikipedia. <http://wikipedia.org/wiki/Diff>`_
 
 runnableExamples:
   assert diffInt(
@@ -37,7 +37,7 @@ jkl"""
 
 # code owner: Arne Döring
 #
-# This is based on C# code written by Matthias Hertel, https://www.mathertel.de
+# This is based on C# code written by Matthias Hertel, http://www.mathertel.de
 #
 # This Class implements the Difference Algorithm published in
 # "An O(ND) Difference Algorithm and its Variations" by Eugene Myers

lib/impure/nre.nim

@@ -37,7 +37,7 @@ runnableExamples:
 ## PCRE has `some additional terms`_ that you must agree to in order to use
 ## this module.
 ##
-## .. _`some additional terms`: https://pcre.sourceforge.net/license.txt
+## .. _`some additional terms`: http://pcre.sourceforge.net/license.txt
 runnableExamples:
   import std/sugar
   let vowels = re"[aeoui]"
@@ -74,14 +74,7 @@ when defined(nimPreviewSlimSystem):
 export options
 
 type
-  RegexDesc* = object
-    pattern*: string
-    pcreObj: ptr pcre.Pcre  ## not nil
-    pcreExtra: ptr pcre.ExtraData  ## nil
-
-    captureNameToId: Table[string, int]
-
-  Regex* = ref RegexDesc
+  Regex* = ref object
     ## Represents the pattern that things are matched against, constructed with
     ## `re(string)`. Examples: `re"foo"`, `re(r"(*ANYCRLF)(?x)foo #
     ## comment".`
@@ -141,17 +134,22 @@ type
     ## -  `(*NO_STUDY)` - turn off studying; study is enabled by default
     ##
     ## For more details on the leading option groups, see the `Option
-    ## Setting <https://man7.org/linux/man-pages/man3/pcresyntax.3.html#OPTION_SETTING>`_
+    ## Setting <http://man7.org/linux/man-pages/man3/pcresyntax.3.html#OPTION_SETTING>`_
     ## and the `Newline
-    ## Convention <https://man7.org/linux/man-pages/man3/pcresyntax.3.html#NEWLINE_CONVENTION>`_
+    ## Convention <http://man7.org/linux/man-pages/man3/pcresyntax.3.html#NEWLINE_CONVENTION>`_
     ## sections of the `PCRE syntax
-    ## manual <https://man7.org/linux/man-pages/man3/pcresyntax.3.html>`_.
+    ## manual <http://man7.org/linux/man-pages/man3/pcresyntax.3.html>`_.
     ##
     ## Some of these options are not part of PCRE and are converted by nre
     ## into PCRE flags. These include `NEVER_UTF`, `ANCHORED`,
     ## `DOLLAR_ENDONLY`, `FIRSTLINE`, `NO_AUTO_CAPTURE`,
     ## `JAVASCRIPT_COMPAT`, `U`, `NO_STUDY`. In other PCRE wrappers, you
     ## will need to pass these as separate flags to PCRE.
+    pattern*: string
+    pcreObj: ptr pcre.Pcre  ## not nil
+    pcreExtra: ptr pcre.ExtraData  ## nil
+
+    captureNameToId: Table[string, int]
 
   RegexMatch* = object
     ## Usually seen as Option[RegexMatch], it represents the result of an
@@ -218,28 +216,12 @@ type
     ## for whatever reason. The message contains the error
     ## code.
 
-when defined(gcDestructors):
-  when defined(nimAllowNonVarDestructor) and defined(nimPreviewNonVarDestructor):
-    proc `=destroy`(pattern: RegexDesc) =
-      `=destroy`(pattern.pattern)
-      pcre.free_substring(cast[cstring](pattern.pcreObj))
-      if pattern.pcreExtra != nil:
-        pcre.free_study(pattern.pcreExtra)
-      `=destroy`(pattern.captureNameToId)
-  else:
-    proc `=destroy`(pattern: var RegexDesc) =
-      `=destroy`(pattern.pattern)
-      pcre.free_substring(cast[cstring](pattern.pcreObj))
-      if pattern.pcreExtra != nil:
-        pcre.free_study(pattern.pcreExtra)
-      `=destroy`(pattern.captureNameToId)
-else:
-  proc destroyRegex(pattern: Regex) =
-    `=destroy`(pattern.pattern)
-    pcre.free_substring(cast[cstring](pattern.pcreObj))
-    if pattern.pcreExtra != nil:
-      pcre.free_study(pattern.pcreExtra)
-    `=destroy`(pattern.captureNameToId)
+proc destroyRegex(pattern: Regex) =
+  `=destroy`(pattern.pattern)
+  pcre.free_substring(cast[cstring](pattern.pcreObj))
+  if pattern.pcreExtra != nil:
+    pcre.free_study(pattern.pcreExtra)
+  `=destroy`(pattern.captureNameToId)
 
 proc getinfo[T](pattern: Regex, opt: cint): T =
   let retcode = pcre.fullinfo(pattern.pcreObj, pattern.pcreExtra, opt, addr result)
@@ -269,10 +251,7 @@ proc getNameToNumberTable(pattern: Regex): Table[string, int] =
     result[name] = num
 
 proc initRegex(pattern: string, flags: int, study = true): Regex =
-  when defined(gcDestructors):
-    result = Regex()
-  else:
-    new(result, destroyRegex)
+  new(result, destroyRegex)
   result.pattern = pattern
 
   var errorMsg: cstring

lib/impure/re.nim

@@ -13,7 +13,7 @@ when defined(js):
 ## Regular expression support for Nim.
 ##
 ## This module is implemented by providing a wrapper around the
-## `PCRE (Perl-Compatible Regular Expressions) <https://www.pcre.org>`_
+## `PCRE (Perl-Compatible Regular Expressions) <http://www.pcre.org>`_
 ## C library. This means that your application will depend on the PCRE
 ## library's licence when using this module, which should not be a problem
 ## though.

lib/js/jscore.nim

@@ -77,10 +77,10 @@ proc newDate*(): DateTime {.
 proc newDate*(date: int|string): DateTime {.
   importcpp: "new Date(#)".}
 
-when jsNoBigInt64:
+whenJsNoBigInt64:
   proc newDate*(date: int64): DateTime {.
     importcpp: "new Date(#)".}
-else:
+do:
   proc newDate*(date: int64): DateTime {.
     importcpp: "new Date(Number(#))".}
 

lib/nimbase.h

@@ -110,7 +110,7 @@ __EMSCRIPTEN__
 
 /*
   NIM_THREADVAR declaration based on
-  https://stackoverflow.com/questions/18298280/how-to-declare-a-variable-as-thread-local-portably
+  http://stackoverflow.com/questions/18298280/how-to-declare-a-variable-as-thread-local-portably
 */
 #if defined _WIN32
 #  if defined _MSC_VER || defined __BORLANDC__
@@ -469,11 +469,16 @@ typedef char* NCSTRING;
 
 #define NIM_STRLIT_FLAG ((NU)(1) << ((NIM_INTBITS) - 2)) /* This has to be the same as system.strlitFlag! */
 
+#define STRING_LITERAL(name, str, length) \
+   static const struct {                   \
+     TGenericSeq Sup;                      \
+     NIM_CHAR data[(length) + 1];          \
+  } name = {{length, (NI) ((NU)length | NIM_STRLIT_FLAG)}, str}
+
 /* declared size of a sequence/variable length array: */
 #if defined(__cplusplus) && defined(__clang__)
 #  define SEQ_DECL_SIZE 1
-#elif defined(__GNUC__) || defined(_MSC_VER) || defined(__TINYC__) || \
-        (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)) // C99
+#elif defined(__GNUC__) || defined(_MSC_VER)
 #  define SEQ_DECL_SIZE /* empty is correct! */
 #else
 #  define SEQ_DECL_SIZE 1000000