fixes

This fixes several cases of the Nim binding of nfds_t being inconsistent
with the target platform signedness and/or size.

Additionally, it fixes poll's third argument (timeout) being set to Nim
"int" when it should have been "cint".

The former is the same issue that #23045 had attempted to fix, but
failed because it only considered Linux. (Also, it was only applied to
version 2.0, so the two branches now have incompatible versions of the
same bug.)

Notes:

* SVR4's original "unsigned long" definition is cloned by Linux and
Haiku. Nim got this right for Haiku and Linux-amd64, but it was wrong on
non-amd64 Linux.
* Zephyr does not have nfds_t, but simply uses (signed) "int". This was
already correctly reflected by Nim.
* OpenBSD poll.h uses "unsigned int", and other BSD derivatives follow
suit. This being the most commonly copied definition, the fallback case
now returns cuint. (This also seems to be correct for the OS X headers I
could find on the web.)
* This changes Nintendo Switch nfds_t to cuint from culong. It is
purportedly a FreeBSD derivative, so I *think* this is correct, but I
can't tell because I don't have access to the Nintendo Switch headers.

I have also moved the platform-specific Tnfds to posix.nim so that we
can reuse the fallback logic on all platforms. (e.g. specifying the size
in posix_linux_amd64 only to then use when defined(linux) in posix_other
seems redundant.)

.github/workflows/bisects.yml

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

.github/workflows/ci_docs.yml

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

.github/workflows/ci_gcc14.yml

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

.github/workflows/ci_packages.yml

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

.github/workflows/ci_publish.yml

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

.gitignore

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

azure-pipelines.yml

@@ -20,7 +20,7 @@ jobs:
   strategy:
     matrix:
       Linux_amd64:
-        vmImage: 'ubuntu-24.04'
+        vmImage: 'ubuntu-20.04'
         CPU: amd64
       # regularly breaks, refs bug #17325
 #       Linux_i386:
@@ -28,24 +28,24 @@ jobs:
 #         # g++-multilib : Depends: gcc-multilib (>= 4:5.3.1-1ubuntu1) but it is not going to be installed
 #         vmImage: 'ubuntu-18.04'
 #         CPU: i386
-      OSX_arm64:
-        vmImage: 'macos-15'
-        CPU: arm64
-      OSX_arm64_cpp:
-        vmImage: 'macos-15'
-        CPU: arm64
+      OSX_amd64:
+        vmImage: 'macOS-13'
+        CPU: amd64
+      OSX_amd64_cpp:
+        vmImage: 'macOS-13'
+        CPU: amd64
         NIM_COMPILE_TO_CPP: true
       Windows_amd64_batch0_3:
-        vmImage: 'windows-2025'
+        vmImage: 'windows-2019'
         CPU: amd64
         # see also: `NIM_TEST_PACKAGES`
         NIM_TESTAMENT_BATCH: "0_3"
       Windows_amd64_batch1_3:
-        vmImage: 'windows-2025'
+        vmImage: 'windows-2019'
         CPU: amd64
         NIM_TESTAMENT_BATCH: "1_3"
       Windows_amd64_batch2_3:
-        vmImage: 'windows-2025'
+        vmImage: 'windows-2019'
         CPU: amd64
         NIM_TESTAMENT_BATCH: "2_3"
 
@@ -80,12 +80,10 @@ jobs:
     - bash: |
         set -e
         . ci/funs.sh
-        echo_run sudo add-apt-repository universe
-        echo_run sudo apt-get update -qq
+        echo_run sudo apt-fast update -qq
         DEBIAN_FRONTEND='noninteractive' \
-          echo_run sudo apt-get install --no-install-recommends -yq \
-            gcc-14 g++-14 libpcre3 liblapack-dev libpcre3 liblapack-dev libcurl4-openssl-dev libgc-dev libsdl1.2-dev libsfml-dev valgrind libc6-dbg
-        echo_run sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-14 60 --slave /usr/bin/g++ g++ /usr/bin/g++-14
+          echo_run sudo apt-fast install --no-install-recommends -yq \
+            libcurl4-openssl-dev libgc-dev libsdl1.2-dev libsfml-dev valgrind libc6-dbg
       displayName: 'Install dependencies (amd64 Linux)'
       condition: and(succeeded(), eq(variables['skipci'], 'false'), eq(variables['Agent.OS'], 'Linux'), eq(variables['CPU'], 'amd64'))
 
@@ -102,16 +100,15 @@ jobs:
         Pin-Priority: 1001
         EOF
 
-        # echo_run sudo apt-get update -qq
-        echo_run sudo apt-get update -qq || echo "failed, see bug #17343"
+        # echo_run sudo apt-fast update -qq
+        echo_run sudo apt-fast update -qq || echo "failed, see bug #17343"
         # `:i386` (e.g. in `libffi-dev:i386`) is needed otherwise you may get:
         # `could not load: libffi.so` during dynamic loading.
         DEBIAN_FRONTEND='noninteractive' \
-          echo_run sudo apt-get install --no-install-recommends --allow-downgrades -yq \
+          echo_run sudo apt-fast install --no-install-recommends --allow-downgrades -yq \
             g++-multilib gcc-multilib libcurl4-openssl-dev:i386 libgc-dev:i386 \
             libsdl1.2-dev:i386 libsfml-dev:i386 libglib2.0-dev:i386 libffi-dev:i386
 
-
         cat << EOF > bin/gcc
         #!/bin/bash
 

changelog.md

@@ -12,116 +12,22 @@ rounding guarantees (via the
   avoid conflicts with `system.default`, so named argument usage for this
   parameter like `getOrDefault(..., default = ...)` will have to be changed.
 
-- With `-d:nimPreviewCheckedClose`, the `close` function in the `std/syncio` module now raises an IO exception in case of an error.
-
-- Unknown warnings and hints now gives warnings `warnUnknownNotes` instead of
-errors.
-
-- With `-d:nimPreviewAsmSemSymbol`, backticked symbols are type checked in the `asm/emit` statements.
-
-- The bare `except:` now panics on `Defect`. Use `except Exception:` or `except Defect:` to catch `Defect`. `--legacy:noPanicOnExcept` is provided for a transition period.
-
-- With `-d:nimPreviewCStringComparisons`, comparsions (`<`, `>`, `<=`, `>=`) between cstrings switch from reference semantics to value semantics like `==` and `!=`.
-
-- `std/parsesql` has been moved to a nimble package, use `nimble` or `atlas` to install it.
-
-- With `-d:nimPreviewDuplicateModuleError`, importing two modules that share the same name becomes a compile-time error. This includes importing the same module more than once. Use `import foo as foo1` (or other aliases) to avoid collisions.
-
-- Adds the switch `--mangle:nim|cpp`, which selects `nim` or `cpp` style name mangling when used with `debuginfo` on, defaults to `nim`. The default is changed from `cpp` to `nim`.
-
-- The second parameter of `succ`, `pred`, `inc`, and `dec` in `system` now accepts `SomeInteger` (previously `Ordinal`).
-
-- Bitshift operators (`shl`, `shr`, `ashr`) now apply bitmasking to the right operand in the C/C++/VM/JS backends.
-
-- Adds a new warning enabled by `--warning:ImplicitRangeConversion` that detects downsizing implicit conversions to range types (e.g., `int -> range[0..255]` or `range[1..256] -> range[0..255]`) that could cause runtime panics. Safe conversions like `range[0..255] -> range[0..65535]` and explicit casts are not warned on.
-
 ## Standard library additions and changes
 
 [//]: # "Additions:"
-
 - `setutils.symmetricDifference` along with its operator version
   `` setutils.`-+-` `` and in-place version `setutils.toggle` have been added
   to more efficiently calculate the symmetric difference of bitsets.
-- `strutils.multiReplace` overload for character set replacements in a single pass.
-	Useful for string sanitation. Follows existing multiReplace semantics.
-
-- `std/files` adds:
-  - Exports `CopyFlag` enum and `FilePermission` type for fine-grained control of file operations
-  - New file operation procs with `Path` support:
-    - `getFilePermissions`, `setFilePermissions` for managing permissions
-    - `tryRemoveFile` for file deletion
-    - `copyFile` with configurable buffer size and symlink handling
-    - `copyFileWithPermissions` to preserve file attributes
-    - `copyFileToDir` for copying files into directories
-
-- `std/dirs` adds:
-  - New directory operation procs with `Path` support:
-    - `copyDir` with special file handling options
-    - `copyDirWithPermissions` to recursively preserve attributes
-
-- `system.setLenUninit` now supports refc, JS and VM backends.
-
-- `std/parseopt` now supports multiple parser modes via a `CliMode` enum.
-  Modes include `Nim` (default, fully compatible) and two new experimental modes:
-  `Lax` and `Gnu` for different option parsing behaviors.
 
 [//]: # "Changes:"
-
 - `std/math` The `^` symbol now supports floating-point as exponent in addition to the Natural type.
-- `min`, `max`, and `sequtils`' `minIndex`, `maxIndex` and `minmax` for `openArray`s now accept a comparison function.
-- `system.substr` implementation now uses `copymem` (wrapped C `memcpy`) for copying data, if available at compilation.
-- `system.newStringUninit` is now considered free of side-effects allowing it to be used with `--experimental:strictFuncs`.
 
 ## Language changes
 
-- An experimental option `--experimental:typeBoundOps` has been added that
-  implements the RFC https://github.com/nim-lang/RFCs/issues/380.
-  This makes the behavior of interfaces like `hash`, `$`, `==` etc. more
-  reliable for nominal types across indirect/restricted imports.
-
-  ```nim
-  # objs.nim
-  import std/hashes
-
-  type
-    Obj* = object
-      x*, y*: int
-      z*: string # to be ignored for equality
-
-  proc `==`*(a, b: Obj): bool =
-    a.x == b.x and a.y == b.y
-
-  proc hash*(a: Obj): Hash =
-    $!(hash(a.x) &! hash(a.y))
-  ```
-
-  ```nim
-  # main.nim
-  {.experimental: "typeBoundOps".}
-  from objs import Obj # objs.hash, objs.`==` not imported
-  import std/tables
-
-  var t: Table[Obj, int]
-  t[Obj(x: 3, y: 4, z: "debug")] = 34
-  echo t[Obj(x: 3, y: 4, z: "ignored")] # 34
-  ```
-
-  See the [experimental manual](https://nim-lang.github.io/Nim/manual_experimental.html#typeminusbound-overloads)
-  for more information.
 
 ## Compiler changes
 
-- Fixed a bug where `sizeof(T)` inside a `typedesc` template called from a generic type's
-  `when` clause would error with "'sizeof' requires '.importc' types to be '.completeStruct'".
-  The issue was that `hasValuelessStatics` in `semtypinst.nim` didn't recognize
-  `tyTypeDesc(tyGenericParam)` as an unresolved generic parameter.
 
 ## Tool changes
 
-- Added `--raw` flag when generating JSON docs to not render markup.
-- Added `--stdinfile` flag to name of the file used when running program from stdin (defaults to `stdinfile.nim`)
-- Added `--styleCheck:warning` flag to treat style check violations as warnings.
 
-## Documentation changes
-
-- Added documentation for the `completeStruct` pragma in the manual.

changelogs/changelog_0_18_1.md

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

changelogs/changelog_1_0_0.md

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

changelogs/changelog_1_0_2.md

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

changelogs/changelog_1_2_0.md

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

changelogs/changelog_2_0_0.md

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

compiler/ast.nim

@@ -279,7 +279,7 @@ const
   GcTypeKinds* = {tyRef, tySequence, tyString}
 
   tyTypeClasses* = {tyBuiltInTypeClass, tyCompositeTypeClass,
-                    tyUserTypeClass, tyUserTypeClassInst, tyConcept,
+                    tyUserTypeClass, tyUserTypeClassInst,
                     tyAnd, tyOr, tyNot, tyAnything}
 
   tyMetaTypes* = {tyGenericParam, tyTypeDesc, tyUntyped} + tyTypeClasses
@@ -447,8 +447,6 @@ const
   tfReturnsNew* = tfInheritable
   tfNonConstExpr* = tfExplicitCallConv
     ## tyFromExpr where the expression shouldn't be evaluated as a static value
-  tfGenericHasDestructor* = tfExplicitCallConv
-    ## tyGenericBody where an instance has a generated destructor
   skError* = skUnknown
 
 var
@@ -500,7 +498,6 @@ type
     mAppendStrCh, mAppendStrStr, mAppendSeqElem,
     mInSet, mRepr, mExit,
     mSetLengthStr, mSetLengthSeq,
-    mSetLengthSeqUninit,
     mIsPartOf, mAstToStr, mParallel,
     mSwap, mIsNil, mArrToSeq, mOpenArrayToSeq,
     mNewString, mNewStringOfCap, mParseBiggestFloat,
@@ -685,7 +682,6 @@ type
     symbols*: TStrTable
     parent*: PScope
     allowPrivateAccess*: seq[PSym] #  # enable access to private fields
-    optionStackLen*: int
 
   PScope* = ref TScope
 
@@ -797,15 +793,6 @@ type
 
   TPairSeq* = seq[TPair]
 
-  TIdPair*[T] = object
-    key*: ItemId
-    val*: T
-
-  TIdPairSeq*[T] = seq[TIdPair[T]]
-  TIdTable*[T] = object
-    counter*: int
-    data*: TIdPairSeq[T]
-
   TNodePair* = object
     h*: Hash                 # because it is expensive to compute!
     key*: PNode
@@ -816,7 +803,6 @@ type
                                 # nodes are compared by structure!
     counter*: int
     data*: TNodePairSeq
-    ignoreTypes*: bool
 
   TObjectSeq* = seq[RootRef]
   TObjectSet* = object
@@ -945,17 +931,16 @@ proc getPIdent*(a: PNode): PIdent {.inline.} =
   case a.kind
   of nkSym: a.sym.name
   of nkIdent: a.ident
-  of nkOpenSymChoice, nkClosedSymChoice, nkOpenSym: a.sons[0].sym.name
+  of nkOpenSymChoice, nkClosedSymChoice: a.sons[0].sym.name
+  of nkOpenSym: getPIdent(a.sons[0])
   else: nil
 
 const
   moduleShift = when defined(cpu32): 20 else: 24
 
-template toId*(a: ItemId): int =
+template id*(a: PType | PSym): int =
   let x = a
-  (x.module.int shl moduleShift) + x.item.int
-
-template id*(a: PType | PSym): int = toId(a.itemId)
+  (x.itemId.module.int shl moduleShift) + x.itemId.item.int
 
 type
   IdGenerator* = ref object # unfortunately, we really need the 'shared mutable' aspect here.
@@ -1282,11 +1267,6 @@ proc copyStrTable*(dest: var TStrTable, src: TStrTable) =
   setLen(dest.data, src.data.len)
   for i in 0..high(src.data): dest.data[i] = src.data[i]
 
-proc copyIdTable*[T](dest: var TIdTable[T], src: TIdTable[T]) =
-  dest.counter = src.counter
-  newSeq(dest.data, src.data.len)
-  for i in 0..high(src.data): dest.data[i] = src.data[i]
-
 proc copyObjectSet*(dest: var TObjectSet, src: TObjectSet) =
   dest.counter = src.counter
   setLen(dest.data, src.data.len)
@@ -1625,22 +1605,12 @@ proc initStrTable*(): TStrTable =
   result = TStrTable(counter: 0)
   newSeq(result.data, StartSize)
 
-proc initIdTable*[T](): TIdTable[T] =
-  result = TIdTable[T](counter: 0)
-  newSeq(result.data, StartSize)
-
-proc resetIdTable*[T](x: var TIdTable[T]) =
-  x.counter = 0
-  # clear and set to old initial size:
-  setLen(x.data, 0)
-  setLen(x.data, StartSize)
-
 proc initObjectSet*(): TObjectSet =
   result = TObjectSet(counter: 0)
   newSeq(result.data, StartSize)
 
-proc initNodeTable*(ignoreTypes=false): TNodeTable =
-  result = TNodeTable(counter: 0, ignoreTypes: ignoreTypes)
+proc initNodeTable*(): TNodeTable =
+  result = TNodeTable(counter: 0)
   newSeq(result.data, StartSize)
 
 proc skipTypes*(t: PType, kinds: TTypeKinds; maxIters: int): PType =
@@ -1675,7 +1645,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
 
@@ -2117,16 +2087,14 @@ proc canRaise*(fn: PNode): bool =
     result = false
   elif fn.kind == nkSym and fn.sym.magic == mEcho:
     result = true
-  elif fn.typ != nil and fn.typ.kind == tyProc and fn.typ.n != nil:
+  else:
     # TODO check for n having sons? or just return false for now if not
-    if fn.typ.n[0].kind == nkSym:
+    if fn.typ != nil and fn.typ.n != nil and fn.typ.n[0].kind == nkSym:
       result = false
     else:
-      result = ((fn.typ.n[0].len < effectListLen) or
+      result = fn.typ != nil and fn.typ.n != nil and ((fn.typ.n[0].len < effectListLen) or
         (fn.typ.n[0][exceptionEffects] != nil and
         fn.typ.n[0][exceptionEffects].safeLen > 0))
-  else:
-    result = false
 
 proc toHumanStrImpl[T](kind: T, num: static int): string =
   result = $kind
@@ -2163,8 +2131,14 @@ proc isTrue*(n: PNode): bool =
     n.kind == nkIntLit and n.intVal != 0
 
 type
-  TypeMapping* = TIdTable[PType]
-  SymMapping* = TIdTable[PSym]
+  TypeMapping* = Table[ItemId, PType]
+  SymMapping* = Table[ItemId, PSym]
 
-template initSymMapping*(): SymMapping = initIdTable[PSym]()
-template initTypeMapping*(): TypeMapping = initIdTable[PType]()
+template idTableGet*(tab: typed; key: PSym | PType): untyped = tab.getOrDefault(key.itemId)
+template idTablePut*(tab: typed; key, val: PSym | PType) = tab[key.itemId] = val
+
+template initSymMapping*(): Table[ItemId, PSym] = initTable[ItemId, PSym]()
+template initTypeMapping*(): Table[ItemId, PType] = initTable[ItemId, PType]()
+
+template resetIdTable*(tab: Table[ItemId, PSym]) = tab.clear()
+template resetIdTable*(tab: Table[ItemId, PType]) = tab.clear()

compiler/astalgo.nim

@@ -713,70 +713,6 @@ iterator items*(tab: TStrTable): PSym =
     yield s
     s = nextIter(it, tab)
 
-proc isNil(x: ItemId): bool {.inline.} =
-  x.module == 0 and x.item == 0
-
-proc hasEmptySlot[T](data: TIdPairSeq[T]): bool =
-  for h in 0..high(data):
-    if isNil(data[h].key):
-      return true
-  result = false
-
-proc idTableRawGet[T](t: TIdTable[T], key: int): int =
-  var h: Hash
-  h = key and high(t.data)    # start with real hash value
-  while not isNil(t.data[h].key):
-    if toId(t.data[h].key) == key:
-      return h
-    h = nextTry(h, high(t.data))
-  result = - 1
-
-proc getOrDefault*[T](t: TIdTable[T], key: ItemId): T =
-  var index = idTableRawGet(t, toId(key))
-  if index >= 0: result = t.data[index].val
-  else: result = default(T)
-
-template idTableGet*[T](t: TIdTable[T], key: PType | PSym): T =
-  getOrDefault(t, key.itemId)
-
-proc idTableRawInsert[T](data: var TIdPairSeq[T], key: ItemId, val: T) =
-  var h: Hash
-  let keyId = toId(key)
-  h = keyId and high(data)
-  while not isNil(data[h].key):
-    assert(toId(data[h].key) != keyId)
-    h = nextTry(h, high(data))
-  assert(isNil(data[h].key))
-  data[h].key = key
-  data[h].val = val
-
-proc `[]=`*[T](t: var TIdTable[T], key: ItemId, val: T) =
-  var
-    index: int
-    n: TIdPairSeq[T]
-  index = idTableRawGet(t, toId(key))
-  if index >= 0:
-    assert(not isNil(t.data[index].key))
-    t.data[index].val = val
-  else:
-    if mustRehash(t.data.len, t.counter):
-      newSeq(n, t.data.len * GrowthFactor)
-      for i in 0..high(t.data):
-        if not isNil(t.data[i].key):
-          idTableRawInsert(n, t.data[i].key, t.data[i].val)
-      assert(hasEmptySlot(n))
-      swap(t.data, n)
-    idTableRawInsert(t.data, key, val)
-    inc(t.counter)
-
-template idTablePut*[T](t: var TIdTable[T], key: PType | PSym, val: T) =
-  t[key.itemId] = val
-
-iterator idTablePairs*[T](t: TIdTable[T]): tuple[key: ItemId, val: T] =
-  for i in 0..high(t.data):
-    if not isNil(t.data[i].key):
-      yield (t.data[i].key, t.data[i].val)
-
 proc initIITable(x: var TIITable) =
   x.counter = 0
   newSeq(x.data, StartSize)

compiler/cbuilder.nim

@@ -1,121 +0,0 @@
-type
-  Snippet = string
-  Builder = string
-
-template newBuilder(s: string): Builder =
-  s
-
-proc addField(obj: var Builder; name, typ: Snippet) =
-  obj.add('\t')
-  obj.add(typ)
-  obj.add(" ")
-  obj.add(name)
-  obj.add(";\n")
-
-proc addField(obj: var Builder; field: PSym; name, typ: Snippet; isFlexArray: bool; initializer: Snippet) =
-  obj.add('\t')
-  if field.alignment > 0:
-    obj.add("NIM_ALIGN(")
-    obj.addInt(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.addInt(field.bitsize)
-  if initializer.len != 0:
-    obj.add(initializer)
-  obj.add(";\n")
-
-proc structOrUnion(t: PType): Snippet =
-  let t = t.skipTypes({tyAlias, tySink})
-  if tfUnion in t.flags: "union"
-  else: "struct"
-
-proc ptrType(t: Snippet): Snippet =
-  t & "*"
-
-template addStruct(obj: var Builder; m: BModule; typ: PType; name: string; baseType: string; body: typed) =
-  if tfPacked in typ.flags:
-    if hasAttribute in CC[m.config.cCompiler].props:
-      obj.add(structOrUnion(typ))
-      obj.add(" __attribute__((__packed__))")
-    else:
-      obj.add("#pragma pack(push, 1)\n")
-      obj.add(structOrUnion(typ))
-  else:
-    obj.add(structOrUnion(typ))
-  obj.add(" ")
-  obj.add(name)
-  type BaseClassKind = enum
-    bcNone, bcCppInherit, bcSupField, bcNoneRtti, bcNoneTinyRtti
-  var baseKind = bcNone
-  if typ.kind == tyObject:
-    if typ.baseClass == nil:
-      if lacksMTypeField(typ):
-        baseKind = bcNone
-      elif optTinyRtti in m.config.globalOptions:
-        baseKind = bcNoneTinyRtti
-      else:
-        baseKind = bcNoneRtti
-    elif m.compileToCpp:
-      baseKind = bcCppInherit
-    else:
-      baseKind = bcSupField
-  if baseKind == bcCppInherit:
-    obj.add(" : public ")
-    obj.add(baseType)
-  obj.add(" ")
-  obj.add("{\n")
-  let currLen = obj.len
-  case 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 typ.itemId notin m.g.graph.memberProcsPerType and
-        typ.n != nil and typ.n.len == 1 and typ.n[0].kind == nkSym and
-        typ.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)
-  body
-  if baseKind == bcNone and currLen == obj.len and typ.itemId notin m.g.graph.memberProcsPerType:
-    # no fields were added, add dummy field
-    obj.addField(name = "dummy", typ = "char")
-  obj.add("};\n")
-  if tfPacked in typ.flags and hasAttribute notin CC[m.config.cCompiler].props:
-    result.add("#pragma pack(pop)\n")
-
-template addFieldWithStructType(obj: var Builder; m: BModule; parentTyp: PType; fieldName: string, body: typed) =
-  ## adds a field with a `struct { ... }` type, building it 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) =
-  obj.add "union{\n"
-  body
-  obj.add("};\n")

compiler/cbuilderbase.nim

@@ -0,0 +1,6 @@
+type
+  Snippet = string
+  Builder = string
+
+template newBuilder(s: string): Builder =
+  s

compiler/cbuilderdecls.nim

@@ -0,0 +1,349 @@
+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 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.addInt(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.addInt(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")
+
+template addArrayTypedef(builder: var Builder, name: string, len: int, typeBody: typed) =
+  ## adds an array typedef declaration to the builder with name `name`,
+  ## length `len`, and element type as built in `typeBody`
+  builder.add("typedef ")
+  typeBody
+  builder.add(" ")
+  builder.add(name)
+  builder.add("[")
+  builder.addInt(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.addInt(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.addInt(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.addInt(field.bitsize)
+  if initializer.len != 0:
+    obj.add(initializer)
+  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.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.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.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.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")

compiler/cbuilderexprs.nim

@@ -0,0 +1,26 @@
+# XXX make complex ones like bitOr use builder instead
+# XXX add stuff like NI, NIM_NIL as constants
+
+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 procPtrType(conv: TCallingConvention, rettype: Snippet, name: string): Snippet =
+  CallingConvToStr[conv] & "_PTR(" & rettype & ", " & name & ")"
+
+proc cCast(typ, value: Snippet): Snippet =
+  "((" & typ & ") " & value & ")"
+
+proc cAddr(value: Snippet): Snippet =
+  "&" & value
+
+proc bitOr(a, b: Snippet): Snippet =
+  "(" & a & " | " & b & ")"

compiler/ccgcalls.nim

@@ -135,7 +135,7 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
           d.snippet = pl
           excl d.flags, lfSingleUse
         else:
-          if d.k == locNone and p.splitDecls == 0 and p.config.exc != excGoto:
+          if d.k == locNone and p.splitDecls == 0:
             d = getTempCpp(p, typ.returnType, pl)
           else:
             if d.k == locNone: d = getTemp(p, typ.returnType)
@@ -307,7 +307,7 @@ proc withTmpIfNeeded(p: BProc, a: TLoc, needsTmp: bool): TLoc =
   else:
     result = a
 
-proc expressionsNeedsTmp(p: BProc, a: TLoc): TLoc =
+proc literalsNeedsTmp(p: BProc, a: TLoc): TLoc =
   result = getTemp(p, a.lode.typ, needsInit=false)
   genAssignment(p, result, a, {})
 
@@ -326,7 +326,7 @@ proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Rope; need
     (optByRef notin param.options or not p.module.compileToCpp):
     a = initLocExpr(p, n)
     if n.kind in {nkCharLit..nkNilLit}:
-      addAddrLoc(p.config, expressionsNeedsTmp(p, a), result)
+      addAddrLoc(p.config, literalsNeedsTmp(p, a), result)
     else:
       addAddrLoc(p.config, withTmpIfNeeded(p, a, needsTmp), result)
   elif p.module.compileToCpp and param.typ.kind in {tyVar} and

compiler/ccgexprs.nim

@@ -13,7 +13,7 @@ when defined(nimCompilerStacktraceHints):
   import std/stackframes
 
 proc getNullValueAuxT(p: BProc; orig, t: PType; obj, constOrNil: PNode,
-                      result: var Rope; count: var int;
+                      result: var Builder; init: var StructInitializer;
                       isConst: bool, info: TLineInfo)
 
 # -------------------------- constant expressions ------------------------
@@ -660,9 +660,9 @@ proc binaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
   of mSubF64: applyFormat("(($4)($1) - ($4)($2))")
   of mMulF64: applyFormat("(($4)($1) * ($4)($2))")
   of mDivF64: applyFormat("(($4)($1) / ($4)($2))")
-  of mShrI: applyFormat("($4)((NU$5)($1) >> (NU$3)($2 & ($5 - 1)))")
-  of mShlI: applyFormat("($4)((NU$3)($1) << (NU$3)($2 & ($5 - 1)))")
-  of mAshrI: applyFormat("($4)((NI$3)($1) >> (NU$3)($2 & ($5 - 1)))")
+  of mShrI: applyFormat("($4)((NU$5)($1) >> (NU$3)($2))")
+  of mShlI: applyFormat("($4)((NU$3)($1) << (NU$3)($2))")
+  of mAshrI: applyFormat("($4)((NI$3)($1) >> (NU$3)($2))")
   of mBitandI: applyFormat("($4)($1 & $2)")
   of mBitorI: applyFormat("($4)($1 | $2)")
   of mBitxorI: applyFormat("($4)($1 ^ $2)")
@@ -766,10 +766,6 @@ proc genDeref(p: BProc, e: PNode, d: var TLoc) =
       return
     else:
       a = initLocExprSingleUse(p, e[0])
-
-    if e.typ != nil and e.typ.kind == tyObject:
-      # bug #23453 #25265
-      discard getTypeDesc(p.module, e.typ)
     if d.k == locNone:
       # dest = *a;  <-- We do not know that 'dest' is on the heap!
       # It is completely wrong to set 'd.storage' here, unless it's not yet
@@ -812,11 +808,6 @@ proc cowBracket(p: BProc; n: PNode) =
 proc cow(p: BProc; n: PNode) {.inline.} =
   if n.kind == nkHiddenAddr: cowBracket(p, n[0])
 
-template ignoreConv(e: PNode): bool =
-  let destType = e.typ.skipTypes({tyVar, tyLent, tyGenericInst, tyAlias, tySink})
-  let srcType = e[1].typ.skipTypes({tyVar, tyLent, tyGenericInst, tyAlias, tySink})
-  sameBackendTypePickyAliases(destType, srcType)
-
 proc genAddr(p: BProc, e: PNode, d: var TLoc) =
   # careful  'addr(myptrToArray)' needs to get the ampersand:
   if e[0].typ.skipTypes(abstractInstOwned).kind in {tyRef, tyPtr}:
@@ -829,15 +820,7 @@ proc genAddr(p: BProc, e: PNode, d: var TLoc) =
     d.lode = e
   else:
     var a: TLoc = initLocExpr(p, e[0])
-    if e[0].kind in {nkHiddenStdConv, nkHiddenSubConv, nkConv} and not ignoreConv(e[0]):
-      # addr (conv x) introduces a temp because `conv x` is not a rvalue
-      # transform addr ( conv ( x ) ) -> conv ( addr ( x ) )
-      var exprLoc: TLoc = initLocExpr(p, e[0][1])
-      var tmp = getTemp(p, e.typ, needsInit=false)
-      putIntoDest(p, tmp, e, "(($1) $2)" % [getTypeDesc(p.module, e.typ), addrLoc(p.config, exprLoc)])
-      putIntoDest(p, d, e, rdLoc(tmp))
-    else:
-      putIntoDest(p, d, e, addrLoc(p.config, a), a.storage)
+    putIntoDest(p, d, e, addrLoc(p.config, a), a.storage)
 
 template inheritLocation(d: var TLoc, a: TLoc) =
   if d.k == locNone: d.storage = a.storage
@@ -852,7 +835,7 @@ proc genTupleElem(p: BProc, e: PNode, d: var TLoc) =
   var
     i: int = 0
   var a: TLoc = initLocExpr(p, e[0])
-  let tupType = a.t.skipTypes(abstractInst+{tyVar}+tyUserTypeClasses) # ref #25227
+  let tupType = a.t.skipTypes(abstractInst+{tyVar})
   assert tupType.kind == tyTuple
   d.inheritLocation(a)
   discard getTypeDesc(p.module, a.t) # fill the record's fields.loc
@@ -1589,10 +1572,6 @@ proc genObjConstr(p: BProc, e: PNode, d: var TLoc) =
   discard getTypeDesc(p.module, t)
   let ty = getUniqueType(t)
   for i in 1..<e.len:
-    if nfPreventCg in e[i].flags:
-      # this is an object constructor node generated by the VM and
-      # this field is in an inactive case branch, don't generate assignment
-      continue
     var check: PNode = nil
     if e[i].len == 3 and optFieldCheck in p.options:
       check = e[i][2]
@@ -1925,14 +1904,7 @@ proc genArrayLen(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
     else: putIntoDest(p, d, e, rope(lengthOrd(p.config, typ)))
   else: internalError(p.config, e.info, "genArrayLen()")
 
-proc isTrivialTypesToSnippet(t: PType): Rope =
-  if containsGarbageCollectedRef(t) or
-                     hasDestructor(t):
-    result = rope"NIM_FALSE"
-  else:
-    result = rope"NIM_TRUE"
-
-proc genSetLengthSeq(p: BProc, e: PNode, d: var TLoc, noinit = false) =
+proc genSetLengthSeq(p: BProc, e: PNode, d: var TLoc) =
   if optSeqDestructors in p.config.globalOptions:
     e[1] = makeAddr(e[1], p.module.idgen)
     genCall(p, e, d)
@@ -1945,22 +1917,17 @@ proc genSetLengthSeq(p: BProc, e: PNode, d: var TLoc, noinit = false) =
   let t = skipTypes(e[1].typ, {tyVar})
 
   var call = initLoc(locCall, e, OnHeap)
-  let name = if noinit: "setLengthSeqUninit" else: "setLengthSeqV2"
   if not p.module.compileToCpp:
-    const setLenPattern = "($3) #$6(($1)?&($1)->Sup:NIM_NIL, $4, $2, $5)"
+    const setLenPattern = "($3) #setLengthSeqV2(($1)?&($1)->Sup:NIM_NIL, $4, $2)"
     call.snippet = ropecg(p.module, setLenPattern, [
       rdLoc(a), rdLoc(b), getTypeDesc(p.module, t),
-      genTypeInfoV1(p.module, t.skipTypes(abstractInst), e.info),
-      isTrivialTypesToSnippet(t.skipTypes(abstractInst)[0]),
-      name])
+      genTypeInfoV1(p.module, t.skipTypes(abstractInst), e.info)])
 
   else:
-    const setLenPattern = "($3) #$6($1, $4, $2, $5)"
+    const setLenPattern = "($3) #setLengthSeqV2($1, $4, $2)"
     call.snippet = ropecg(p.module, setLenPattern, [
       rdLoc(a), rdLoc(b), getTypeDesc(p.module, t),
-      genTypeInfoV1(p.module, t.skipTypes(abstractInst), e.info),
-      isTrivialTypesToSnippet(t.skipTypes(abstractInst)[0]),
-      name])
+      genTypeInfoV1(p.module, t.skipTypes(abstractInst), e.info)])
 
   genAssignment(p, a, call, {})
   gcUsage(p.config, e)
@@ -2188,8 +2155,6 @@ proc genSomeCast(p: BProc, e: PNode, d: var TLoc) =
           [getTypeDesc(p.module, e.typ), rdCharLoc(a)], a.storage)
     elif etyp.kind == tyBool and srcTyp.kind in IntegralTypes:
       putIntoDest(p, d, e, "(($1) != 0)" % [rdCharLoc(a)], a.storage)
-    elif etyp.kind == tyProc and srcTyp.kind == tyProc and sameBackendType(etyp, srcTyp):
-      expr(p, e[1], d)
     else:
       if etyp.kind == tyPtr:
         # generates the definition of structs for casts like cast[ptr object](addr x)[]
@@ -2282,7 +2247,8 @@ proc genRangeChck(p: BProc, n: PNode, d: var TLoc) =
       [getTypeDesc(p.module, dest), rdCharLoc(a)], a.storage)
 
 proc genConv(p: BProc, e: PNode, d: var TLoc) =
-  if ignoreConv(e):
+  let destType = e.typ.skipTypes({tyVar, tyLent, tyGenericInst, tyAlias, tySink})
+  if sameBackendTypeIgnoreRange(destType, e[1].typ):
     expr(p, e[1], d)
   else:
     genSomeCast(p, e, d)
@@ -2583,7 +2549,6 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
     unaryStmt(p, e, d, "if ($1) { #nimGCunref($1); }$n")
   of mSetLengthStr: genSetLengthStr(p, e, d)
   of mSetLengthSeq: genSetLengthSeq(p, e, d)
-  of mSetLengthSeqUninit: genSetLengthSeq(p, e, d, noinit = true)
   of mIncl, mExcl, mCard, mLtSet, mLeSet, mEqSet, mMulSet, mPlusSet, mMinusSet,
      mInSet, mXorSet:
     genSetOp(p, e, d, op)
@@ -2853,11 +2818,7 @@ proc upConv(p: BProc, n: PNode, d: var TLoc) =
     raiseInstr(p, p.s(cpsStmts))
     linefmt p, cpsStmts, "}$n", []
 
-  # skip cast when types map to the same C type
-  # this avoids invalid C code like `*(T*)&x` for types that can't have their address taken (e.g., WASM __externref_t)
-  if getTypeDesc(p.module, n.typ) == getTypeDesc(p.module, n[0].typ):
-    expr(p, n[0], d)
-  elif n[0].typ.kind != tyObject:
+  if n[0].typ.kind != tyObject:
     if n.isLValue:
       putIntoDest(p, d, n,
                 "(*(($1*) (&($2))))" % [getTypeDesc(p.module, n.typ), rdLoc(a)], a.storage)
@@ -2885,7 +2846,7 @@ proc downConv(p: BProc, n: PNode, d: var TLoc) =
     var a: TLoc = initLocExpr(p, arg)
     putIntoDest(p, d, n,
               "(*(($1*) (&($2))))" % [getTypeDesc(p.module, n.typ), rdLoc(a)], a.storage)
-  elif p.module.compileToCpp or isImportedType(src):
+  elif p.module.compileToCpp:
     # C++ implicitly downcasts for us
     expr(p, arg, d)
   else:
@@ -3113,7 +3074,16 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
   of nkObjConstr: genObjConstr(p, n, d)
   of nkCast: genCast(p, n, d)
   of nkHiddenStdConv, nkHiddenSubConv, nkConv: genConv(p, n, d)
-  of nkAddr, nkHiddenAddr: genAddr(p, n, d)
+  of nkHiddenAddr:
+    if n[0].kind == nkDerefExpr:
+      # addr ( deref ( x )) --> x
+      var x = n[0][0]
+      if n.typ.skipTypes(abstractVar).kind != tyOpenArray:
+        x.typ() = n.typ
+      expr(p, x, d)
+      return
+    genAddr(p, n, d)
+  of nkAddr: genAddr(p, n, d)
   of nkBracketExpr: genBracketExpr(p, n, d)
   of nkDerefExpr, nkHiddenDeref: genDeref(p, n, d)
   of nkDotExpr: genRecordField(p, n, d)
@@ -3144,12 +3114,6 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
   of nkConstSection:
     if useAliveDataFromDce in p.module.flags:
       genConstStmt(p, n)
-    else: # enforce addressable consts for exportc
-      let m = p.module
-      for it in n:
-        let symNode = skipPragmaExpr(it[0])
-        if symNode.kind == nkSym and sfExportc in symNode.sym.flags:
-          requestConstImpl(p, symNode.sym)
     # else: consts generated lazily on use
   of nkForStmt: internalError(p.config, n.info, "for statement not eliminated")
   of nkCaseStmt: genCase(p, n, d)
@@ -3231,7 +3195,7 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
   of nkMixinStmt, nkBindStmt: discard
   else: internalError(p.config, n.info, "expr(" & $n.kind & "); unknown node kind")
 
-proc getDefaultValue(p: BProc; typ: PType; info: TLineInfo; result: var Rope) =
+proc getDefaultValue(p: BProc; typ: PType; info: TLineInfo; result: var Builder) =
   var t = skipTypes(typ, abstractRange+{tyOwned}-{tyTypeDesc})
   case t.kind
   of tyBool: result.add rope"NIM_FALSE"
@@ -3242,38 +3206,56 @@ proc getDefaultValue(p: BProc; typ: PType; info: TLineInfo; result: var Rope) =
     result.add rope"NIM_NIL"
   of tyString, tySequence:
     if optSeqDestructors in p.config.globalOptions:
-      result.add "{0, NIM_NIL}"
+      var seqInit: StructInitializer
+      result.addStructInitializer(seqInit, kind = siOrderedStruct):
+        result.addField(seqInit, name = "len"):
+          result.add("0")
+        result.addField(seqInit, name = "p"):
+          result.add("NIM_NIL")
     else:
       result.add "NIM_NIL"
   of tyProc:
     if t.callConv != ccClosure:
       result.add "NIM_NIL"
     else:
-      result.add "{NIM_NIL, NIM_NIL}"
+      var closureInit: StructInitializer
+      result.addStructInitializer(closureInit, kind = siOrderedStruct):
+        result.addField(closureInit, name = "ClP_0"):
+          result.add("NIM_NIL")
+        result.addField(closureInit, name = "ClE_0"):
+          result.add("NIM_NIL")
   of tyObject:
-    var count = 0
-    result.add "{"
-    getNullValueAuxT(p, t, t, t.n, nil, result, count, true, info)
-    result.add "}"
+    var objInit: StructInitializer
+    result.addStructInitializer(objInit, kind = siOrderedStruct):
+      getNullValueAuxT(p, t, t, t.n, nil, result, objInit, true, info)
   of tyTuple:
-    result.add "{"
-    if p.vccAndC and t.isEmptyTupleType:
-      result.add "0"
-    for i, a in t.ikids:
-      if i > 0: result.add ", "
-      getDefaultValue(p, a, info, result)
-    result.add "}"
+    var tupleInit: StructInitializer
+    result.addStructInitializer(tupleInit, kind = siOrderedStruct):
+      if p.vccAndC and t.isEmptyTupleType:
+        result.addField(tupleInit, name = "dummy"):
+          result.add "0"
+      for i, a in t.ikids:
+        result.addField(tupleInit, name = "Field" & $i):
+          getDefaultValue(p, a, info, result)
   of tyArray:
-    result.add "{"
-    for i in 0..<toInt(lengthOrd(p.config, t.indexType)):
-      if i > 0: result.add ", "
-      getDefaultValue(p, t.elementType, info, result)
-    result.add "}"
+    var arrInit: StructInitializer
+    result.addStructInitializer(arrInit, kind = siArray):
+      for i in 0..<toInt(lengthOrd(p.config, t.indexType)):
+        result.addField(arrInit, name = ""):
+          getDefaultValue(p, t.elementType, info, result)
     #result = rope"{}"
   of tyOpenArray, tyVarargs:
-    result.add "{NIM_NIL, 0}"
+    var openArrInit: StructInitializer
+    result.addStructInitializer(openArrInit, kind = siOrderedStruct):
+      result.addField(openArrInit, name = "Field0"):
+        result.add("NIM_NIL")
+      result.addField(openArrInit, name = "Field1"):
+        result.add("0")
   of tySet:
-    if mapSetType(p.config, t) == ctArray: result.add "{}"
+    if mapSetType(p.config, t) == ctArray:
+      var setInit: StructInitializer
+      result.addStructInitializer(setInit, kind = siArray):
+        discard
     else: result.add "0"
   else:
     globalError(p.config, info, "cannot create null element for: " & $t.kind)
@@ -3284,16 +3266,18 @@ proc isEmptyCaseObjectBranch(n: PNode): bool =
   return true
 
 proc getNullValueAux(p: BProc; t: PType; obj, constOrNil: PNode,
-                     result: var Rope; count: var int;
+                     result: var Builder; init: var StructInitializer;
                      isConst: bool, info: TLineInfo) =
   case obj.kind
   of nkRecList:
+    let isUnion = tfUnion in t.flags
     for it in obj.sons:
-      getNullValueAux(p, t, it, constOrNil, result, count, isConst, info)
+      getNullValueAux(p, t, it, constOrNil, result, init, isConst, info)
+      if isUnion:
+        # generate only 1 field for default value of union
+        return
   of nkRecCase:
-    getNullValueAux(p, t, obj[0], constOrNil, result, count, isConst, info)
-    var res = ""
-    if count > 0: res.add ", "
+    getNullValueAux(p, t, obj[0], constOrNil, result, init, isConst, info)
     var branch = Zero
     if constOrNil != nil:
       ## find kind value, default is zero if not specified
@@ -3307,140 +3291,186 @@ proc getNullValueAux(p: BProc; t: PType; obj, constOrNil: PNode,
           break
 
     let selectedBranch = caseObjDefaultBranch(obj, branch)
-    res.add "{"
-    var countB = 0
     let b = lastSon(obj[selectedBranch])
     # designated initilization is the only way to init non first element of unions
     # branches are allowed to have no members (b.len == 0), in this case they don't need initializer
+    var fieldName: string = ""
     if b.kind == nkRecList and not isEmptyCaseObjectBranch(b):
-      res.add "._" & mangleRecFieldName(p.module, obj[0].sym) & "_" & $selectedBranch & " = {"
-      getNullValueAux(p, t,  b, constOrNil, res, countB, isConst, info)
-      res.add "}"
+      fieldName = "_" & mangleRecFieldName(p.module, obj[0].sym) & "_" & $selectedBranch
+      result.addField(init, name = "<anonymous union>"):
+        # XXX figure out name for the union, see use of `addAnonUnion`
+        var branchInit: StructInitializer
+        result.addStructInitializer(branchInit, kind = siNamedStruct):
+          result.addField(branchInit, name = fieldName):
+            var branchObjInit: StructInitializer
+            result.addStructInitializer(branchObjInit, kind = siOrderedStruct):
+              getNullValueAux(p, t, b, constOrNil, result, branchObjInit, isConst, info)
     elif b.kind == nkSym:
-      res.add "." & mangleRecFieldName(p.module, b.sym) & " = "
-      getNullValueAux(p, t,  b, constOrNil, res, countB, isConst, info)
+      fieldName = mangleRecFieldName(p.module, b.sym)
+      result.addField(init, name = "<anonymous union>"):
+        # XXX figure out name for the union, see use of `addAnonUnion`
+        var branchInit: StructInitializer
+        result.addStructInitializer(branchInit, kind = siNamedStruct):
+          result.addField(branchInit, name = fieldName):
+            # we need to generate the default value of the single sym,
+            # to do this create a dummy wrapper initializer and recurse
+            var branchFieldInit: StructInitializer
+            result.addStructInitializer(branchFieldInit, kind = siWrapper):
+              getNullValueAux(p, t, b, constOrNil, result, branchFieldInit, isConst, info)
     else:
+      # no fields, don't initialize
       return
-    result.add res
-    result.add "}"
 
   of nkSym:
-    if count > 0: result.add ", "
-    inc count
     let field = obj.sym
-    if constOrNil != nil:
-      for i in 1..<constOrNil.len:
-        if constOrNil[i].kind == nkExprColonExpr:
-          assert constOrNil[i][0].kind == nkSym, "illformed object constr; the field is not a sym"
-          if constOrNil[i][0].sym.name.id == field.name.id:
-            genBracedInit(p, constOrNil[i][1], isConst, field.typ, result)
-            return
-        elif i == field.position:
-          genBracedInit(p, constOrNil[i], isConst, field.typ, result)
-          return
-    # not found, produce default value:
-    getDefaultValue(p, field.typ, info, result)
+    let sname = mangleRecFieldName(p.module, field)
+    result.addField(init, name = sname):
+      block fieldInit:
+        if constOrNil != nil:
+          for i in 1..<constOrNil.len:
+            if constOrNil[i].kind == nkExprColonExpr:
+              assert constOrNil[i][0].kind == nkSym, "illformed object constr; the field is not a sym"
+              if constOrNil[i][0].sym.name.id == field.name.id:
+                genBracedInit(p, constOrNil[i][1], isConst, field.typ, result)
+                break fieldInit
+            elif i == field.position:
+              genBracedInit(p, constOrNil[i], isConst, field.typ, result)
+              break fieldInit
+        # not found, produce default value:
+        getDefaultValue(p, field.typ, info, result)
   else:
     localError(p.config, info, "cannot create null element for: " & $obj)
 
 proc getNullValueAuxT(p: BProc; orig, t: PType; obj, constOrNil: PNode,
-                      result: var Rope; count: var int;
+                      result: var Builder; init: var StructInitializer;
                       isConst: bool, info: TLineInfo) =
   var base = t.baseClass
-  let oldRes = result
-  let oldcount = count
+  when false:
+    let oldRes = result
+    let oldcount = count
   if base != nil:
-    result.add "{"
     base = skipTypes(base, skipPtrs)
-    getNullValueAuxT(p, orig, base, base.n, constOrNil, result, count, isConst, info)
-    result.add "}"
+    result.addField(init, name = "Sup"):
+      var baseInit: StructInitializer
+      result.addStructInitializer(baseInit, kind = siOrderedStruct):
+        getNullValueAuxT(p, orig, base, base.n, constOrNil, result, baseInit, isConst, info)
   elif not isObjLackingTypeField(t):
-    if optTinyRtti in p.config.globalOptions:
-      result.add genTypeInfoV2(p.module, orig, obj.info)
-    else:
-      result.add genTypeInfoV1(p.module, orig, obj.info)
-    inc count
-  getNullValueAux(p, t, obj, constOrNil, result, count, isConst, info)
-  # do not emit '{}' as that is not valid C:
-  if oldcount == count: result = oldRes
+    result.addField(init, name = "m_type"):
+      if optTinyRtti in p.config.globalOptions:
+        result.add genTypeInfoV2(p.module, orig, obj.info)
+      else:
+        result.add genTypeInfoV1(p.module, orig, obj.info)
+  getNullValueAux(p, t, obj, constOrNil, result, init, isConst, info)
+  when false: # referring to Sup field, hopefully not a problem
+    # do not emit '{}' as that is not valid C:
+    if oldcount == count: result = oldRes
 
-proc genConstObjConstr(p: BProc; n: PNode; isConst: bool; result: var Rope) =
+proc genConstObjConstr(p: BProc; n: PNode; isConst: bool; result: var Builder) =
   let t = n.typ.skipTypes(abstractInstOwned)
-  var count = 0
   #if not isObjLackingTypeField(t) and not p.module.compileToCpp:
   #  result.addf("{$1}", [genTypeInfo(p.module, t)])
   #  inc count
-  result.add "{"
-  if t.kind == tyObject:
-    getNullValueAuxT(p, t, t, t.n, n, result, count, isConst, n.info)
-  result.add("}\n")
+  var objInit: StructInitializer
+  result.addStructInitializer(objInit, kind = siOrderedStruct):
+    if t.kind == tyObject:
+      getNullValueAuxT(p, t, t, t.n, n, result, objInit, isConst, n.info)
 
-proc genConstSimpleList(p: BProc, n: PNode; isConst: bool; result: var Rope) =
-  result.add "{"
-  if p.vccAndC and n.len == 0 and n.typ.kind == tyArray:
-    getDefaultValue(p, n.typ.elementType, n.info, result)
-  for i in 0..<n.len:
-    let it = n[i]
-    if i > 0: result.add ",\n"
-    if it.kind == nkExprColonExpr: genBracedInit(p, it[1], isConst, it[0].typ, result)
-    else: genBracedInit(p, it, isConst, it.typ, result)
-  result.add("}\n")
-
-proc genConstTuple(p: BProc, n: PNode; isConst: bool; tup: PType; result: var Rope) =
-  result.add "{"
-  if p.vccAndC and n.len == 0:
-    result.add "0"
-  for i in 0..<n.len:
-    let it = n[i]
-    if i > 0: result.add ",\n"
-    if it.kind == nkExprColonExpr: genBracedInit(p, it[1], isConst, tup[i], result)
-    else: genBracedInit(p, it, isConst, tup[i], result)
-  result.add("}\n")
-
-proc genConstSeq(p: BProc, n: PNode, t: PType; isConst: bool; result: var Rope) =
-  var data = "{{$1, $1 | NIM_STRLIT_FLAG}" % [n.len.rope]
-  let base = t.skipTypes(abstractInst)[0]
-  if n.len > 0:
-    # array part needs extra curlies:
-    data.add(", {")
+proc genConstSimpleList(p: BProc, n: PNode; isConst: bool; result: var Builder) =
+  var arrInit: StructInitializer
+  result.addStructInitializer(arrInit, kind = siArray):
+    if p.vccAndC and n.len == 0 and n.typ.kind == tyArray:
+      result.addField(arrInit, name = ""):
+        getDefaultValue(p, n.typ.elementType, n.info, result)
     for i in 0..<n.len:
-      if i > 0: data.addf(",$n", [])
-      genBracedInit(p, n[i], isConst, base, data)
-    data.add("}")
-  data.add("}")
+      let it = n[i]
+      var ind, val: PNode
+      if it.kind == nkExprColonExpr:
+        ind = it[0]
+        val = it[1]
+      else:
+        ind = it
+        val = it
+      result.addField(arrInit, name = ""):
+        genBracedInit(p, val, isConst, ind.typ, result)
 
+proc genConstTuple(p: BProc, n: PNode; isConst: bool; tup: PType; result: var Builder) =
+  var tupleInit: StructInitializer
+  result.addStructInitializer(tupleInit, kind = siOrderedStruct):
+    if p.vccAndC and n.len == 0:
+      result.addField(tupleInit, name = "dummy"):
+        result.add("0")
+    for i in 0..<n.len:
+      var it = n[i]
+      if it.kind == nkExprColonExpr:
+        it = it[1]
+      result.addField(tupleInit, name = "Field" & $i):
+        genBracedInit(p, it, isConst, tup[i], result)
+
+proc genConstSeq(p: BProc, n: PNode, t: PType; isConst: bool; result: var Builder) =
+  let base = t.skipTypes(abstractInst)[0]
   let tmpName = getTempName(p.module)
 
-  appcg(p.module, cfsStrData,
-        "static $5 struct {$n" &
-        "  #TGenericSeq Sup;$n" &
-        "  $1 data[$2];$n" &
-        "} $3 = $4;$n", [
-        getTypeDesc(p.module, base), n.len, tmpName, data,
-        if isConst: "NIM_CONST" else: ""])
+  var def = newBuilder("")
+  def.addVarWithTypeAndInitializer(
+      if isConst: Const else: Global,
+      name = tmpName):
+    def.addSimpleStruct(p.module, name = "", baseType = ""):
+      def.addField(name = "sup", typ = cgsymValue(p.module, "TGenericSeq"))
+      def.addArrayField(name = "data", elementType = getTypeDesc(p.module, base), len = n.len)
+  do:
+    var structInit: StructInitializer
+    def.addStructInitializer(structInit, kind = siOrderedStruct):
+      def.addField(structInit, name = "sup"):
+        var supInit: StructInitializer
+        def.addStructInitializer(supInit, kind = siOrderedStruct):
+          def.addField(supInit, name = "len"):
+            def.add(n.len.rope)
+          def.addField(supInit, name = "reserved"):
+            def.add(bitOr(rope(n.len), "NIM_STRLIT_FLAG"))
+      if n.len > 0:
+        def.addField(structInit, name = "data"):
+          var arrInit: StructInitializer
+          def.addStructInitializer(arrInit, kind = siArray):
+            for i in 0..<n.len:
+              def.addField(arrInit, name = ""):
+                genBracedInit(p, n[i], isConst, base, def)
+  p.module.s[cfsStrData].add def
 
-  result.add "(($1)&$2)" % [getTypeDesc(p.module, t), tmpName]
+  result.add cCast(typ = getTypeDesc(p.module, t), value = cAddr(tmpName))
 
-proc genConstSeqV2(p: BProc, n: PNode, t: PType; isConst: bool; result: var Rope) =
+proc genConstSeqV2(p: BProc, n: PNode, t: PType; isConst: bool; result: var Builder) =
   let base = t.skipTypes(abstractInst)[0]
-  var data = rope""
-  if n.len > 0:
-    data.add(", {")
-    for i in 0..<n.len:
-      if i > 0: data.addf(",$n", [])
-      genBracedInit(p, n[i], isConst, base, data)
-    data.add("}")
-
   let payload = getTempName(p.module)
-  appcg(p.module, cfsStrData,
-    "static $5 struct {$n" &
-    "  NI cap; $1 data[$2];$n" &
-    "} $3 = {$2 | NIM_STRLIT_FLAG$4};$n", [
-    getTypeDesc(p.module, base), n.len, payload, data,
-    if isConst: "const" else: ""])
-  result.add "{$1, ($2*)&$3}" % [rope(n.len), getSeqPayloadType(p.module, t), payload]
 
-proc genBracedInit(p: BProc, n: PNode; isConst: bool; optionalType: PType; result: var Rope) =
+  var def = newBuilder("")
+  def.addVarWithTypeAndInitializer(
+      if isConst: AlwaysConst else: Global,
+      name = payload):
+    def.addSimpleStruct(p.module, name = "", baseType = ""):
+      def.addField(name = "cap", typ = "NI")
+      def.addArrayField(name = "data", elementType = getTypeDesc(p.module, base), len = n.len)
+  do:
+    var structInit: StructInitializer
+    def.addStructInitializer(structInit, kind = siOrderedStruct):
+      def.addField(structInit, name = "cap"):
+        def.add(bitOr(rope(n.len), "NIM_STRLIT_FLAG"))
+      if n.len > 0:
+        def.addField(structInit, name = "data"):
+          var arrInit: StructInitializer
+          def.addStructInitializer(arrInit, kind = siArray):
+            for i in 0..<n.len:
+              def.addField(arrInit, name = ""):
+                genBracedInit(p, n[i], isConst, base, def)
+  p.module.s[cfsStrData].add def
+
+  var resultInit: StructInitializer
+  result.addStructInitializer(resultInit, kind = siOrderedStruct):
+    result.addField(resultInit, name = "len"):
+      result.add(rope(n.len))
+    result.addField(resultInit, name = "p"):
+      result.add cCast(typ = ptrType(getSeqPayloadType(p.module, t)), value = cAddr(payload))
+
+proc genBracedInit(p: BProc, n: PNode; isConst: bool; optionalType: PType; result: var Builder) =
   case n.kind
   of nkHiddenStdConv, nkHiddenSubConv:
     genBracedInit(p, n[1], isConst, n.typ, result)
@@ -3475,11 +3505,16 @@ proc genBracedInit(p: BProc, n: PNode; isConst: bool; optionalType: PType; resul
         # in VM closures are initialized with nkPar(nkNilLit, nkNilLit)
         # leading to duplicate code like this:
         # "{NIM_NIL,NIM_NIL}, {NIM_NIL,NIM_NIL}"
-        if n[0].kind == nkNilLit:
-          result.add "{NIM_NIL,NIM_NIL}"
-        else:
-          var d: TLoc = initLocExpr(p, n[0])
-          result.add "{(($1) $2),NIM_NIL}" % [getClosureType(p.module, typ, clHalfWithEnv), rdLoc(d)]
+        var closureInit: StructInitializer
+        result.addStructInitializer(closureInit, kind = siOrderedStruct):
+          result.addField(closureInit, name = "ClP_0"):
+            if n[0].kind == nkNilLit:
+              result.add("NIM_NIL")
+            else:
+              var d: TLoc = initLocExpr(p, n[0])
+              result.add(cCast(typ = getClosureType(p.module, typ, clHalfWithEnv), value = rdLoc(d)))
+          result.addField(closureInit, name = "ClE_0"):
+            result.add("NIM_NIL")
       else:
         var d: TLoc = initLocExpr(p, n)
         result.add rdLoc(d)
@@ -3491,17 +3526,21 @@ proc genBracedInit(p: BProc, n: PNode; isConst: bool; optionalType: PType; resul
       if n.kind != nkBracket:
         internalError(p.config, n.info, "const openArray expression is not an array construction")
 
-      var data = newRopeAppender()
-      genConstSimpleList(p, n, isConst, data)
-
       let payload = getTempName(p.module)
       let ctype = getTypeDesc(p.module, typ.elementType)
       let arrLen = n.len
-      appcg(p.module, cfsStrData,
-        "static $5 $1 $3[$2] = $4;$n", [
-        ctype, arrLen, payload, data,
-        if isConst: "const" else: ""])
-      result.add "{($1*)&$2, $3}" % [ctype, payload, rope arrLen]
+      var data = newBuilder("")
+      data.addArrayVarWithInitializer(
+          kind = if isConst: AlwaysConst else: Global,
+          name = payload, elementType = ctype, len = arrLen):
+        genConstSimpleList(p, n, isConst, data)
+      p.module.s[cfsStrData].add(data)
+      var openArrInit: StructInitializer
+      result.addStructInitializer(openArrInit, kind = siOrderedStruct):
+        result.addField(openArrInit, name = "Field0"):
+          result.add(cCast(typ = ptrType(ctype), value = cAddr(payload)))
+        result.addField(openArrInit, name = "Field1"):
+          result.add(rope arrLen)
 
     of tyObject:
       genConstObjConstr(p, n, isConst, result)

compiler/ccgliterals.nim

@@ -36,50 +36,83 @@ proc genStringLiteralDataOnlyV1(m: BModule, s: string; result: var Rope) =
   cgsym(m, "TGenericSeq")
   let tmp = getTempName(m)
   result.add tmp
-  m.s[cfsStrData].addf("STRING_LITERAL($1, $2, $3);$n",
-       [tmp, makeCString(s), rope(s.len)])
+  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.add(rope(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(res)
 
 proc genStringLiteralV1(m: BModule; n: PNode; result: var Rope) =
   if s.isNil:
-    appcg(m, result, "((#NimStringDesc*) NIM_NIL)", [])
+    result.add(cCast(ptrType(cgsymValue(m, "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:
-      appcg(m, result, "((#NimStringDesc*) &", [])
-      genStringLiteralDataOnlyV1(m, n.strVal, result)
-      result.add ")"
+      genStringLiteralDataOnlyV1(m, n.strVal, name)
     else:
-      appcg(m, result, "((#NimStringDesc*) &$1$2)",
-                      [m.tmpBase, id])
+      name = m.tmpBase & $id
+    result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), cAddr(name)))
 
 # ------ Version 2: destructor based strings and seqs -----------------------
 
 proc genStringLiteralDataOnlyV2(m: BModule, s: string; result: Rope; isConst: bool) =
-  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: "")])
+  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(res)
 
 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:
-    m.s[cfsStrData].addf("static $4 NimStringV2 $1 = {$2, (NimStrPayload*)&$3};$n",
-          [tmp, rope(n.strVal.len), pureLit, rope(if isConst: "const" else: "")])
+    litName = getTempName(m)
+    genStringLiteralDataOnlyV2(m, n.strVal, litName, isConst)
   else:
-    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: "")])
+    litName = m.tmpBase & $id
+  let tmp = getTempName(m)
+  result.add tmp
+  var res = newBuilder("")
+  res.addVarWithTypeAndInitializer(
+      if isConst: AlwaysConst else: Global,
+      name = tmp):
+    res.add("NimStringV2")
+  do:
+    var strInit: StructInitializer
+    res.addStructInitializer(strInit, kind = siOrderedStruct):
+      res.addField(strInit, name = "len"):
+        res.add(rope(n.strVal.len))
+      res.addField(strInit, name = "p"):
+        res.add(cCast(ptrType("NimStrPayload"), cAddr(litName)))
+  m.s[cfsStrData].add(res)
 
 proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Rope) =
   let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
@@ -92,7 +125,12 @@ proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Ro
     genStringLiteralDataOnlyV2(m, n.strVal, pureLit, isConst)
   else:
     pureLit = m.tmpBase & rope(id)
-  result.addf "{$1, (NimStrPayload*)&$2}", [rope(n.strVal.len), pureLit]
+  var strInit: StructInitializer
+  result.addStructInitializer(strInit, kind = siOrderedStruct):
+    result.addField(strInit, name = "len"):
+      result.add(rope(n.strVal.len))
+    result.addField(strInit, name = "p"):
+      result.add(cCast(ptrType("NimStrPayload"), cAddr(pureLit)))
 
 # ------ Version selector ---------------------------------------------------
 
@@ -108,7 +146,7 @@ proc genStringLiteralDataOnly(m: BModule; s: string; info: TLineInfo;
     localError(m.config, info, "cannot determine how to produce code for string literal")
 
 proc genNilStringLiteral(m: BModule; info: TLineInfo; result: var Rope) =
-  appcg(m, result, "((#NimStringDesc*) NIM_NIL)", [])
+  result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), "NIM_NIL"))
 
 proc genStringLiteral(m: BModule; n: PNode; result: var Rope) =
   case detectStrVersion(m)

compiler/ccgreset.nim

@@ -66,13 +66,7 @@ proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
     var x = typ.baseClass
     if x != nil: x = x.skipTypes(skipPtrs)
     specializeResetT(p, accessor.parentObj(p.module), x)
-    if typ.n != nil:
-      if typ.sym != nil and sfImportc in typ.sym.flags:
-        # imported C struct, nimZeroMem
-        lineCg(p, cpsStmts, "#nimZeroMem((void**)&$1, sizeof($2));$n",
-            [accessor, getTypeDesc(p.module, typ)])
-      else:
-        specializeResetN(p, accessor, typ.n, typ)
+    if typ.n != nil: specializeResetN(p, accessor, typ.n, typ)
   of tyTuple:
     let typ = getUniqueType(typ)
     for i, a in typ.ikids:

compiler/ccgstmts.nim

@@ -18,7 +18,7 @@ proc registerTraverseProc(p: BProc, v: PSym) =
   var traverseProc = ""
   if p.config.selectedGC in {gcMarkAndSweep, gcHooks, gcRefc} and
       optOwnedRefs notin p.config.globalOptions and
-      containsManagedMemory(v.loc.t):
+      containsGarbageCollectedRef(v.loc.t):
     # we register a specialized marked proc here; this has the advantage
     # that it works out of the box for thread local storage then :-)
     traverseProc = genTraverseProcForGlobal(p.module, v, v.info)
@@ -202,7 +202,7 @@ proc genState(p: BProc, n: PNode) =
   elif n0.kind == nkStrLit:
     linefmt(p, cpsStmts, "$1: ;$n", [n0.strVal])
 
-proc blockLeaveActions(p: BProc, howManyTrys, howManyExcepts: int, isReturnStmt = false) =
+proc blockLeaveActions(p: BProc, howManyTrys, howManyExcepts: int) =
   # Called by return and break stmts.
   # Deals with issues faced when jumping out of try/except/finally stmts.
 
@@ -234,7 +234,7 @@ proc blockLeaveActions(p: BProc, howManyTrys, howManyExcepts: int, isReturnStmt
 
   # Pop exceptions that was handled by the
   # except-blocks we are in
-  if noSafePoints notin p.flags and not (isReturnStmt and isClosureIterator(p.prc.typ)):
+  if noSafePoints notin p.flags:
     for i in countdown(howManyExcepts-1, 0):
       linefmt(p, cpsStmts, "#popCurrentException();$n", [])
 
@@ -279,7 +279,7 @@ 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 Rope)
+proc genBracedInit(p: BProc, n: PNode; isConst: bool; optionalType: PType; 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:
@@ -509,8 +509,7 @@ proc genReturnStmt(p: BProc, t: PNode) =
   if (t[0].kind != nkEmpty): genStmts(p, t[0])
   blockLeaveActions(p,
     howManyTrys    = p.nestedTryStmts.len,
-    howManyExcepts = p.inExceptBlockLen,
-    isReturnStmt = true)
+    howManyExcepts = p.inExceptBlockLen)
   if (p.finallySafePoints.len > 0) and noSafePoints notin p.flags:
     # If we're in a finally block, and we came here by exception
     # consume it before we return.

compiler/ccgthreadvars.nim

@@ -47,7 +47,11 @@ 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].addf("typedef struct {$1} NimThreadVars;$n", [m.g.nimtv])
+    var typedef = newBuilder("")
+    typedef.addTypedef(name = "NimThreadVars"):
+      typedef.addSimpleStruct(m, name = "", baseType = ""):
+        typedef.add(m.g.nimtv)
+    m.s[cfsSeqTypes].add(typedef)
 
 proc generateThreadVarsSize(m: BModule) =
   if m.g.nimtv != "":

compiler/ccgtypes.nim

@@ -57,15 +57,11 @@ proc mangleField(m: BModule; name: PIdent): string =
 
 proc mangleProc(m: BModule; s: PSym; makeUnique: bool): string =
   result = "_Z"  # Common prefix in Itanium ABI
-  var params = ""
-  var staticLists = ""
+  result.add encodeSym(m, s, makeUnique)
   if s.typ.len > 1: #we dont care about the return param
     for i in 1..<s.typ.len:
       if s.typ[i].isNil: continue
-      params.add encodeType(m, s.typ[i], staticLists)
-
-  result.add encodeSym(m, s, makeUnique, staticLists)
-  result.add params
+      result.add encodeType(m, s.typ[i])
 
   if result in m.g.mangledPrcs:
     result = mangleProc(m, s, true)
@@ -75,7 +71,7 @@ proc mangleProc(m: BModule; s: PSym; makeUnique: bool): string =
 proc fillBackendName(m: BModule; s: PSym) =
   if s.loc.snippet == "":
     var result: Rope
-    if s.kind in routineKinds and {optCDebug, optItaniumMangle} * m.g.config.globalOptions == {optCDebug, optItaniumMangle} and
+    if not m.compileToCpp and s.kind in routineKinds and optCDebug in m.g.config.globalOptions and
       m.g.config.symbolFiles == disabledSf:
       result = mangleProc(m, s, false).rope
     else:
@@ -85,6 +81,7 @@ proc fillBackendName(m: BModule; s: PSym) =
       result.add '_'
       result.add(idOrSig(s, m.module.name.s.mangle, m.sigConflicts, m.config))
     s.loc.snippet = result
+    writeMangledName(m.ndi, s, m.config)
 
 proc fillParamName(m: BModule; s: PSym) =
   if s.loc.snippet == "":
@@ -108,6 +105,7 @@ proc fillParamName(m: BModule; s: PSym) =
     # That would lead to either needing to reload `proxy` or to overwrite the
     # executable file for the main module, which is running (or both!) -> error.
     s.loc.snippet = res.rope
+    writeMangledName(m.ndi, s, m.config)
 
 proc fillLocalName(p: BProc; s: PSym) =
   assert s.kind in skLocalVars+{skTemp}
@@ -119,10 +117,11 @@ proc fillLocalName(p: BProc; s: PSym) =
     if s.kind == skTemp:
       # speed up conflict search for temps (these are quite common):
       if counter != 0: result.add "_" & rope(counter+1)
-    elif s.kind != skResult:
+    elif counter != 0 or isKeyword(s.name) or p.module.g.config.cppDefines.contains(key):
       result.add "_" & rope(counter+1)
     p.sigConflicts.inc(key)
     s.loc.snippet = result
+    if s.kind != skTemp: writeMangledName(p.module.ndi, s, p.config)
 
 proc scopeMangledParam(p: BProc; param: PSym) =
   ## parameter generation only takes BModule, not a BProc, so we have to
@@ -247,11 +246,14 @@ proc isOrHasImportedCppType(typ: PType): bool =
   searchTypeFor(typ.skipTypes({tyRef}), isImportedCppType)
 
 proc hasNoInit(t: PType): bool =
-  let t = skipTypes(t, {tyGenericInst})
   result = t.sym != nil and sfNoInit in t.sym.flags
 
 proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDescKind): Rope
 
+proc isObjLackingTypeField(typ: PType): bool {.inline.} =
+  result = (typ.kind == tyObject) and ((tfFinal in typ.flags) and
+      (typ.baseClass == nil) or isPureObject(typ))
+
 proc isInvalidReturnType(conf: ConfigRef; typ: PType, isProc = true): bool =
   # Arrays and sets cannot be returned by a C procedure, because C is
   # such a poor programming language.
@@ -283,15 +285,6 @@ proc isInvalidReturnType(conf: ConfigRef; typ: PType, isProc = true): bool =
 
     else: result = false
 
-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 cacheGetType(tab: TypeCache; sig: SigHash): Rope =
   # returns nil if we need to declare this type
   # since types are now unique via the ``getUniqueType`` mechanism, this slow
@@ -299,12 +292,7 @@ proc cacheGetType(tab: TypeCache; sig: SigHash): Rope =
   result = tab.getOrDefault(sig)
 
 proc addAbiCheck(m: BModule; t: PType, name: Rope) =
-  if isDefined(m.config, "checkAbi") and (let size = getSize(m.config, t); size != szUnknownSize) and
-    not (t.kind == tyObject and searchTypeFor(t, proc (t: PType): bool {.nimcall.} = t.kind == tyUncheckedArray)):
-    # `UncheckedArray`, not `ptr UncheckedArray` type field in object types is a flexible array.
-    # `sizeof` in C and Nim doesn't always return the same value for object types containing it.
-    # making `getSize` in Nim always returns the same value as `sizeof` in C from flexible arrays seems hard.
-    # See `SEQ_DECL_SIZE` in lib/nimbase.h
+  if isDefined(m.config, "checkAbi") and (let size = getSize(m.config, t); size != szUnknownSize):
     var msg = "backend & Nim disagree on size for: "
     msg.addTypeHeader(m.config, t)
     var msg2 = ""
@@ -385,6 +373,7 @@ proc getTypePre(m: BModule; typ: PType; sig: SigHash): Rope =
     if result == "": result = cacheGetType(m.typeCache, sig)
 
 proc addForwardStructFormat(m: BModule; structOrUnion: Rope, typename: Rope) =
+  # XXX should be no-op in NIFC
   if m.compileToCpp:
     m.s[cfsForwardTypes].addf "$1 $2;$n", [structOrUnion, typename]
   else:
@@ -441,10 +430,11 @@ proc getTypeDescWeak(m: BModule; t: PType; check: var IntSet; kind: TypeDescKind
       if cacheGetType(m.typeCache, sig) == "":
         m.typeCache[sig] = result
         #echo "adding ", sig, " ", typeToString(t), " ", m.module.name.s
-        appcg(m, m.s[cfsTypes],
-          "struct $1 {\n" &
-          "  NI len; $1_Content* p;\n" &
-          "};\n", [result])
+        var struct = newBuilder("")
+        struct.addSimpleStruct(m, name = result, baseType = ""):
+          struct.addField(name = "len", typ = "NI")
+          struct.addField(name = "p", typ = ptrType(result & "_Content"))
+        m.s[cfsTypes].add(struct)
         pushType(m, t)
     else:
       result = getTypeForward(m, t, sig) & seqStar(m)
@@ -463,9 +453,13 @@ proc seqV2ContentType(m: BModule; t: PType; check: var IntSet) =
   if result == "":
     discard getTypeDescAux(m, t, check, dkVar)
   else:
-    appcg(m, m.s[cfsTypes], """
-struct $2_Content { NI cap; $1 data[SEQ_DECL_SIZE]; };
-""", [getTypeDescAux(m, t.skipTypes(abstractInst)[0], check, dkVar), result])
+    var struct = newBuilder("")
+    struct.addSimpleStruct(m, name = result & "_Content", baseType = ""):
+      struct.addField(name = "cap", typ = "NI")
+      struct.addField(name = "data",
+        typ = getTypeDescAux(m, t.skipTypes(abstractInst)[0], check, dkVar),
+        isFlexArray = true)
+    m.s[cfsTypes].add(struct)
 
 proc paramStorageLoc(param: PSym): TStorageLoc =
   if param.typ.skipTypes({tyVar, tyLent, tyTypeDesc}).kind notin {
@@ -603,7 +597,7 @@ proc genProcParams(m: BModule; t: PType, rettype, params: var Rope,
   if t.returnType == nil or isInvalidReturnType(m.config, t):
     rettype = "void"
   else:
-    rettype = getTypeDescWeak(m, t.returnType, check, dkResult)
+    rettype = getTypeDescAux(m, t.returnType, check, dkResult)
   for i in 1..<t.n.len:
     if t.n[i].kind != nkSym: internalError(m.config, t.n.info, "genProcParams")
     var param = t.n[i].sym
@@ -728,6 +722,7 @@ proc genRecordFieldsAux(m: BModule; n: PNode,
       else: internalError(m.config, "genRecordFieldsAux(record case branch)")
     if unionBody.len != 0:
       result.addAnonUnion:
+        # XXX this has to be a named field for NIFC
         result.add(unionBody)
   of nkSym:
     let field = n.sym
@@ -786,8 +781,6 @@ proc fillObjectFields*(m: BModule; typ: PType) =
   var check = initIntSet()
   var ignored = newBuilder("")
   addRecordFields(ignored, m, typ, check)
-  if typ.baseClass != nil:
-    fillObjectFields(m, typ.baseClass.skipTypes(skipPtrs))
 
 proc mangleDynLibProc(sym: PSym): Rope
 
@@ -854,8 +847,12 @@ proc getOpenArrayDesc(m: BModule; t: PType, check: var IntSet; kind: TypeDescKin
       result = getTypeName(m, t, sig)
       m.typeCache[sig] = result
       let elemType = getTypeDescWeak(m, t.elementType, check, kind)
-      m.s[cfsTypes].addf("typedef struct {$n$2* Field0;$nNI Field1;$n} $1;$n",
-                         [result, elemType])
+      var typedef = newBuilder("")
+      typedef.addTypedef(name = result):
+        typedef.addSimpleStruct(m, name = "", baseType = ""):
+          typedef.addField(name = "Field0", typ = ptrType(elemType))
+          typedef.addField(name = "Field1", typ = "NI")
+      m.s[cfsTypes].add(typedef)
 
 proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDescKind): Rope =
   # returns only the type's name
@@ -927,17 +924,28 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
           (sfImportc in t.sym.flags and t.sym.magic == mNone)):
         m.typeCache[sig] = result
         var size: int
+        var typedef = newBuilder("")
         if firstOrd(m.config, t) < 0:
-          m.s[cfsTypes].addf("typedef NI32 $1;$n", [result])
+          typedef.addTypedef(name = result):
+            typedef.add("NI32")
           size = 4
         else:
           size = int(getSize(m.config, t))
           case size
-          of 1: m.s[cfsTypes].addf("typedef NU8 $1;$n", [result])
-          of 2: m.s[cfsTypes].addf("typedef NU16 $1;$n", [result])
-          of 4: m.s[cfsTypes].addf("typedef NI32 $1;$n", [result])
-          of 8: m.s[cfsTypes].addf("typedef NI64 $1;$n", [result])
+          of 1:
+            typedef.addTypedef(name = result):
+              typedef.add("NU8")
+          of 2:
+            typedef.addTypedef(name = result):
+              typedef.add("NU16")
+          of 4:
+            typedef.addTypedef(name = result):
+              typedef.add("NI32")
+          of 8:
+            typedef.addTypedef(name = result):
+              typedef.add("NI64")
           else: internalError(m.config, t.sym.info, "getTypeDescAux: enum")
+        m.s[cfsTypes].add(typedef)
         when false:
           let owner = hashOwner(t.sym)
           if not gDebugInfo.hasEnum(t.sym.name.s, t.sym.info.line, owner):
@@ -954,14 +962,17 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
     var rettype, desc: Rope = ""
     genProcParams(m, t, rettype, desc, check, true, true)
     if not isImportedType(t):
+      var typedef = newBuilder("")
       if t.callConv != ccClosure: # procedure vars may need a closure!
-        m.s[cfsTypes].addf("typedef $1_PTR($2, $3) $4;$n",
-             [rope(CallingConvToStr[t.callConv]), rettype, result, desc])
+        typedef.addTypedef(name = desc):
+          typedef.add(procPtrType(t.callConv, rettype = rettype, name = result))
       else:
-        m.s[cfsTypes].addf("typedef struct {$n" &
-            "N_NIMCALL_PTR($2, ClP_0) $3;$n" &
-            "void* ClE_0;$n} $1;$n",
-             [result, rettype, desc])
+        typedef.addTypedef(name = result):
+          typedef.addSimpleStruct(m, name = "", baseType = ""):
+            typedef.addField(name = desc, typ =
+              procPtrType(ccNimCall, rettype = rettype, name = "ClP_0"))
+            typedef.addField(name = "ClE_0", typ = "void*")
+      m.s[cfsTypes].add(typedef)
   of tySequence:
     if optSeqDestructors in m.config.globalOptions:
       result = getTypeDescWeak(m, t, check, kind)
@@ -978,18 +989,14 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
       m.typeCache[sig] = result & seqStar(m)
       if not isImportedType(t):
         if skipTypes(t.elementType, typedescInst).kind != tyEmpty:
-          const
-            cppSeq = "struct $2 : #TGenericSeq {$n"
-            cSeq = "struct $2 {$n" &
-                  "  #TGenericSeq Sup;$n"
-          if m.compileToCpp:
-            appcg(m, m.s[cfsSeqTypes],
-                cppSeq & "  $1 data[SEQ_DECL_SIZE];$n" &
-                "};$n", [getTypeDescAux(m, t.elementType, check, kind), result])
-          else:
-            appcg(m, m.s[cfsSeqTypes],
-                cSeq & "  $1 data[SEQ_DECL_SIZE];$n" &
-                "};$n", [getTypeDescAux(m, t.elementType, check, kind), result])
+          var struct = newBuilder("")
+          let baseType = cgsymValue(m, "TGenericSeq")
+          struct.addSimpleStruct(m, name = result, baseType = baseType):
+            struct.addField(
+              name = "data",
+              typ = getTypeDescAux(m, t.elementType, check, kind),
+              isFlexArray = true)
+          m.s[cfsSeqTypes].add struct
         else:
           result = rope("TGenericSeq")
       result.add(seqStar(m))
@@ -998,7 +1005,10 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
     m.typeCache[sig] = result
     if not isImportedType(t):
       let foo = getTypeDescAux(m, t.elementType, check, kind)
-      m.s[cfsTypes].addf("typedef $1 $2[1];$n", [foo, result])
+      var typedef = newBuilder("")
+      typedef.addArrayTypedef(name = result, len = 1):
+        typedef.add(foo)
+      m.s[cfsTypes].add(typedef)
   of tyArray:
     var n: BiggestInt = toInt64(lengthOrd(m.config, t))
     if n <= 0: n = 1   # make an array of at least one element
@@ -1006,8 +1016,10 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
     m.typeCache[sig] = result
     if not isImportedType(t):
       let e = getTypeDescAux(m, t.elementType, check, kind)
-      m.s[cfsTypes].addf("typedef $1 $2[$3];$n",
-           [e, result, rope(n)])
+      var typedef = newBuilder("")
+      typedef.addArrayTypedef(name = result, len = n):
+        typedef.add(e)
+      m.s[cfsTypes].add(typedef)
   of tyObject, tyTuple:
     let tt = origTyp.skipTypes({tyDistinct})
     if isImportedCppType(t) and tt.kind == tyGenericInst:
@@ -1053,7 +1065,8 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
       # with the C macros for defining procs such as N_NIMCALL. We must
       # create a typedef for the type and use it in the proc signature:
       let typedefName = "TY" & $sig
-      m.s[cfsTypes].addf("typedef $1 $2;$n", [result, typedefName])
+      m.s[cfsTypes].addTypedef(name = typedefName):
+        m.s[cfsTypes].add(result)
       m.typeCache[sig] = typedefName
       result = typedefName
     else:
@@ -1070,7 +1083,6 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
                       else: getTupleDesc(m, t, result, check)
         if not isImportedType(t):
           m.s[cfsTypes].add(recdesc)
-          addAbiCheck(m, t, result)
         elif tfIncompleteStruct notin t.flags:
           discard # addAbiCheck(m, t, result) # already handled elsewhere
   of tySet:
@@ -1082,9 +1094,12 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
     if not isImportedType(t):
       let s = int(getSize(m.config, t))
       case s
-      of 1, 2, 4, 8: m.s[cfsTypes].addf("typedef NU$2 $1;$n", [result, rope(s*8)])
-      else: m.s[cfsTypes].addf("typedef NU8 $1[$2];$n",
-             [result, rope(getSize(m.config, t))])
+      of 1, 2, 4, 8:
+        m.s[cfsTypes].addTypedef(name = result):
+          m.s[cfsTypes].add("NU" & rope(s*8))
+      else:
+        m.s[cfsTypes].addArrayTypedef(name = result, len = s):
+          m.s[cfsTypes].add("NU8")
   of tyGenericInst, tyDistinct, tyOrdinal, tyTypeDesc, tyAlias, tySink, tyOwned,
      tyUserTypeClass, tyUserTypeClassInst, tyInferred:
     result = getTypeDescAux(m, skipModifier(t), check, kind)
@@ -1112,14 +1127,17 @@ proc getClosureType(m: BModule; t: PType, kind: TClosureTypeKind): Rope =
   var rettype, desc: Rope = ""
   genProcParams(m, t, rettype, desc, check, declareEnvironment=kind != clHalf)
   if not isImportedType(t):
+    var typedef = newBuilder("")
     if t.callConv != ccClosure or kind != clFull:
-      m.s[cfsTypes].addf("typedef $1_PTR($2, $3) $4;$n",
-           [rope(CallingConvToStr[t.callConv]), rettype, result, desc])
+      typedef.addTypedef(name = desc):
+        typedef.add(procPtrType(t.callConv, rettype = rettype, name = result))
     else:
-      m.s[cfsTypes].addf("typedef struct {$n" &
-          "N_NIMCALL_PTR($2, ClP_0) $3;$n" &
-          "void* ClE_0;$n} $1;$n",
-           [result, rettype, desc])
+      typedef.addTypedef(name = result):
+        typedef.addSimpleStruct(m, name = "", baseType = ""):
+          typedef.addField(name = desc, typ =
+            procPtrType(ccNimCall, rettype = rettype, name = "ClP_0"))
+          typedef.addField(name = "ClE_0", typ = "void*")
+    m.s[cfsTypes].add(typedef)
 
 proc finishTypeDescriptions(m: BModule) =
   var i = 0
@@ -1893,9 +1911,6 @@ proc genTypeInfoV1(m: BModule; t: PType; info: TLineInfo): Rope =
   of tyRef:
     genTypeInfoAux(m, t, t, result, info)
     if m.config.selectedGC in {gcMarkAndSweep, gcRefc, gcGo}:
-      # it may not be used in other places except in `genTraverseProc`,
-      # we have to generate a typedesc for this case, not a weak one
-      discard getTypeDesc(m, origType.last)
       let markerProc = genTraverseProc(m, origType, sig)
       m.s[cfsTypeInit3].addf("$1.marker = $2;$n", [tiNameForHcr(m, result), markerProc])
   of tyPtr, tyRange, tyUncheckedArray: genTypeInfoAux(m, t, t, result, info)

compiler/ccgutils.nim

@@ -11,7 +11,7 @@
 
 import
   ast, types, msgs, wordrecg,
-  platform, trees, options, cgendata, mangleutils, renderer
+  platform, trees, options, cgendata, mangleutils
 
 import std/[hashes, strutils, formatfloat]
 
@@ -120,14 +120,14 @@ proc makeUnique(m: BModule; s: PSym, name: string = ""): string =
   result.add "_u"
   result.add $s.itemId.item
 
-proc encodeSym*(m: BModule; s: PSym; makeUnique: bool = false; extra: string = ""): string =
+proc encodeSym*(m: BModule; s: PSym; makeUnique: bool = false): string =
   #Module::Type
-  var name = s.name.s & extra
+  var name = s.name.s
   if makeUnique:
     name = makeUnique(m, s, name)
   "N" & encodeName(s.skipGenericOwner.name.s) & encodeName(name) & "E"
 
-proc encodeType*(m: BModule; t: PType; staticLists: var string): string =
+proc encodeType*(m: BModule; t: PType): string =
   result = ""
   var kindName = ($t.kind)[2..^1]
   kindName[0] = toLower($kindName[0])[0]
@@ -138,10 +138,10 @@ proc encodeType*(m: BModule; t: PType; staticLists: var string): string =
     result = encodeName(t[0].sym.name.s)
     result.add "I"
     for i in 1..<t.len - 1:
-      result.add encodeType(m, t[i], staticLists)
+      result.add encodeType(m, t[i])
     result.add "E"
   of tySequence, tyOpenArray, tyArray, tyVarargs, tyTuple, tyProc, tySet, tyTypeDesc,
-    tyPtr, tyRef, tyVar, tyLent, tySink, tyUncheckedArray, tyOr, tyAnd, tyBuiltInTypeClass:
+    tyPtr, tyRef, tyVar, tyLent, tySink, tyStatic, tyUncheckedArray, tyOr, tyAnd, tyBuiltInTypeClass:
     result =
       case t.kind:
       of tySequence: encodeName("seq")
@@ -150,13 +150,8 @@ proc encodeType*(m: BModule; t: PType; staticLists: var string): string =
     for i in 0..<t.len:
       let s = t[i]
       if s.isNil: continue
-      result.add encodeType(m, s, staticLists)
+      result.add encodeType(m, s)
     result.add "E"
-  of tyStatic:
-    if t.n != nil:
-      staticLists.add "_s" & renderTree(t.n)
-    else:
-      raiseAssert "unreachable"
   of tyRange:
     var val = "range_"
     if t.n[0].typ.kind in {tyFloat..tyFloat128}:
@@ -169,7 +164,7 @@ proc encodeType*(m: BModule; t: PType; staticLists: var string): string =
   of tyString..tyUInt64, tyPointer, tyBool, tyChar, tyVoid, tyAnything, tyNil, tyEmpty:
     result = encodeName(kindName)
   of tyAlias, tyInferred, tyOwned:
-    result = encodeType(m, t.elementType, staticLists)
+    result = encodeType(m, t.elementType)
   else:
     assert false, "encodeType " & $t.kind
 

compiler/cgen.nim

@@ -14,7 +14,7 @@ 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
 
@@ -315,10 +315,7 @@ proc genLineDir(p: BProc, t: PNode) =
   let line = t.info.safeLineNm
 
   if optEmbedOrigSrc in p.config.globalOptions:
-    var code = sourceLine(p.config, t.info)
-    if code.endsWith('\\'):
-      code.add "#"
-    p.s(cpsStmts).add("// " & code & "\L")
+    p.s(cpsStmts).add("//" & sourceLine(p.config, t.info) & "\L")
   let lastFileIndex = p.lastLineInfo.fileIndex
   let freshLine = freshLineInfo(p, t.info)
   if freshLine:
@@ -376,7 +373,9 @@ proc dataField(p: BProc): Rope =
 
 proc genProcPrototype(m: BModule, sym: PSym)
 
-include cbuilder
+include cbuilderbase
+include cbuilderexprs
+include cbuilderdecls
 include ccgliterals
 include ccgtypes
 
@@ -1153,14 +1152,7 @@ proc allPathsAsgnResult(p: BProc; n: PNode): InitResultEnum =
       else:
         allPathsInBranch(n[i].lastSon)
   of nkCallKinds:
-    if canRaiseDisp(p, n[0]) or
-        (n[0].kind == nkSym and sfNoReturn in n[0].sym.flags):
-      # requires initializations when encountering unreachable code
-      result = InitRequired
-    elif n[0].kind == nkSym and
-        n[0].sym.magic in {mUnaryMinusI..mAbsI, mAddI..mPred} and
-          optOverflowCheck in p.config.options:
-      # arithmetic operations may raise exceptions
+    if canRaiseDisp(p, n[0]):
       result = InitRequired
     else:
       for i in 0..<n.safeLen:
@@ -2095,6 +2087,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))
@@ -2178,23 +2173,6 @@ proc addHcrInitGuards(p: BProc, n: PNode, inInitGuard: var bool) =
 
     genStmts(p, n)
 
-proc handleProcGlobals(m: BModule) =
-  var procGlobals: seq[PNode] = move m.g.graph.procGlobals
-
-  for i in 0..<procGlobals.len:
-    var stmts = ""
-
-    # fixes recursive calls #24997
-    swap stmts, m.preInitProc.s(cpsStmts)
-    var transformedN = procGlobals[i]
-    if sfInjectDestructors in m.module.flags:
-      transformedN = injectDestructorCalls(m.g.graph, m.idgen, m.module, transformedN)
-    genStmts(m.preInitProc, transformedN)
-    swap stmts, m.preInitProc.s(cpsStmts)
-
-    handleProcGlobals(m)
-    m.preInitProc.s(cpsStmts).add stmts
-
 proc genTopLevelStmt*(m: BModule; n: PNode) =
   ## Also called from `ic/cbackend.nim`.
   if pipelineutils.skipCodegen(m.config, n): return
@@ -2210,8 +2188,6 @@ proc genTopLevelStmt*(m: BModule; n: PNode) =
   else:
     genProcBody(m.initProc, transformedN)
 
-  handleProcGlobals(m)
-
 proc shouldRecompile(m: BModule; code: Rope, cfile: Cfile): bool =
   if optForceFullMake notin m.config.globalOptions:
     if not moduleHasChanged(m.g.graph, m.module):
@@ -2243,6 +2219,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)
@@ -2260,10 +2237,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)
@@ -2275,13 +2254,12 @@ proc updateCachedModule(m: BModule) =
   addFileToCompile(m.config, cf)
 
 proc generateLibraryDestroyGlobals(graph: ModuleGraph; m: BModule; body: PNode; isDynlib: bool): PSym =
-  let prefixedName = m.config.nimMainPrefix & "NimDestroyGlobals"
-  let procname = getIdent(graph.cache, prefixedName)
+  let procname = getIdent(graph.cache, "NimDestroyGlobals")
   result = newSym(skProc, procname, m.idgen, m.module.owner, m.module.info)
   result.typ = newProcType(m.module.info, m.idgen, m.module.owner)
   result.typ.callConv = ccCDecl
   incl result.flags, sfExportc
-  result.loc.snippet = prefixedName
+  result.loc.snippet = "NimDestroyGlobals"
   if isDynlib:
     incl(result.loc.flags, lfExportLib)
 

compiler/cgendata.nim

@@ -11,7 +11,7 @@
 
 import
   ast, ropes, options,
-  lineinfos, pathutils, modulegraphs
+  ndi, lineinfos, pathutils, modulegraphs
 
 import std/[intsets, tables, sets]
 
@@ -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

compiler/commands.nim

@@ -118,7 +118,7 @@ const
   errInvalidCmdLineOption = "invalid command line option: '$1'"
   errOnOrOffExpectedButXFound = "'on' or 'off' expected, but '$1' found"
   errOnOffOrListExpectedButXFound = "'on', 'off' or 'list' expected, but '$1' found"
-  errOffHintsError = "'off', 'hint', 'warning', 'error' or 'usages' expected, but '$1' found"
+  errOffHintsError = "'off', 'hint', 'error' or 'usages' expected, but '$1' found"
 
 proc invalidCmdLineOption(conf: ConfigRef; pass: TCmdLinePass, switch: string, info: TLineInfo) =
   if switch == " ": localError(conf, info, errInvalidCmdLineOption % "-")
@@ -203,14 +203,13 @@ proc processSpecificNote*(arg: string, state: TSpecialWord, pass: TCmdLinePass,
   else: invalidCmdLineOption(conf, pass, orig, info)
 
   let isSomeHint = state in {wHint, wHintAsError}
-  let isSomeWarning = state in {wWarning, wWarningAsError}
   template findNote(noteMin, noteMax, name) =
     # unfortunately, hintUser and warningUser clash, otherwise implementation would simplify a bit
     let x = findStr(noteMin, noteMax, id, errUnknown)
     if x != errUnknown: notes = {TNoteKind(x)}
     else:
-      if isSomeHint or isSomeWarning:
-        message(conf, info, warnUnknownNotes, "unknown $#: $#" % [name, id])
+      if isSomeHint:
+        message(conf, info, hintUnknownHint, id)
       else:
         localError(conf, info, "unknown $#: $#" % [name, id])
   case id.normalize
@@ -364,7 +363,6 @@ proc testCompileOption*(conf: ConfigRef; switch: string, info: TLineInfo): bool
     result = false
   of "panics": result = contains(conf.globalOptions, optPanics)
   of "jsbigint64": result = contains(conf.globalOptions, optJsBigInt64)
-  of "mangle": result = contains(conf.globalOptions, optItaniumMangle)
   else:
     result = false
     invalidCmdLineOption(conf, passCmd1, switch, info)
@@ -460,7 +458,7 @@ template handleStdinOrCmdInput =
     conf.outDir = getNimcacheDir(conf)
 
 proc handleStdinInput*(conf: ConfigRef) =
-  conf.projectName = conf.stdinFile.string
+  conf.projectName = "stdinfile"
   conf.projectIsStdin = true
   handleStdinOrCmdInput()
 
@@ -761,14 +759,6 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
       conf.globalOptions.excl optCDebug
     else:
       localError(conf, info, "expected native|gdb|on|off but found " & arg)
-  of "mangle":
-    case arg.normalize
-    of "nim":
-      conf.globalOptions.excl optItaniumMangle
-    of "cpp":
-      conf.globalOptions.incl optItaniumMangle
-    else:
-      localError(conf, info, "expected nim|cpp but found " & arg)
   of "g": # alias for --debugger:native
     conf.globalOptions.incl optCDebug
     conf.options.incl optLineDir
@@ -891,19 +881,11 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
   of "import":
     expectArg(conf, switch, arg, pass, info)
     if pass in {passCmd2, passPP}:
-      let m = findModule(conf, arg, toFullPath(conf, info)).string
-      if m.len == 0:
-        localError(conf, info, "Cannot resolve filename: " & arg)
-      else:
-        conf.implicitImports.add m
+      conf.implicitImports.add findModule(conf, arg, toFullPath(conf, info)).string
   of "include":
     expectArg(conf, switch, arg, pass, info)
     if pass in {passCmd2, passPP}:
-      let m = findModule(conf, arg, toFullPath(conf, info)).string
-      if m.len == 0:
-        localError(conf, info, "Cannot resolve filename: " & arg)
-      else:
-        conf.implicitIncludes.add m
+      conf.implicitIncludes.add findModule(conf, arg, toFullPath(conf, info)).string
   of "listcmd":
     processOnOffSwitchG(conf, {optListCmd}, arg, pass, info)
   of "asm":
@@ -937,12 +919,6 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
     discard parseSaturatedNatural(arg, value)
     if not value > 0: localError(conf, info, "maxLoopIterationsVM must be a positive integer greater than zero")
     conf.maxLoopIterationsVM = value
-  of "maxcalldepthvm":
-    expectArg(conf, switch, arg, pass, info)
-    var value: int = 2_000
-    discard parseSaturatedNatural(arg, value)
-    if value <= 0: localError(conf, info, "maxCallDepthVM must be a positive integer greater than zero")
-    conf.maxCallDepthVM = value
   of "errormax":
     expectArg(conf, switch, arg, pass, info)
     # Note: `nim check` (etc) can overwrite this.
@@ -952,10 +928,6 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
     var value: int = 0
     discard parseSaturatedNatural(arg, value)
     conf.errorMax = if value == 0: high(int) else: value
-  of "stdinfile":
-    expectArg(conf, switch, arg, pass, info)
-    conf.stdinFile = if os.isAbsolute(arg): AbsoluteFile(arg)
-                     else: AbsoluteFile(getCurrentDir() / arg)
   of "verbosity":
     expectArg(conf, switch, arg, pass, info)
     let verbosity = parseInt(arg)
@@ -1097,9 +1069,6 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
   of "shownonexports":
     expectNoArg(conf, switch, arg, pass, info)
     showNonExportedFields(conf)
-  of "raw":
-    expectNoArg(conf, switch, arg, pass, info)
-    docRawOutput(conf)
   of "exceptions":
     case arg.normalize
     of "cpp": conf.exc = excCpp
@@ -1131,10 +1100,9 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
       defineSymbol(conf.symbols, "nimSeqsV2")
   of "stylecheck":
     case arg.normalize
-    of "off": conf.globalOptions = conf.globalOptions - {optStyleHint, optStyleError, optStyleWarning}
-    of "hint": conf.globalOptions = conf.globalOptions + {optStyleHint} - {optStyleError, optStyleWarning}
-    of "warning": conf.globalOptions = conf.globalOptions + {optStyleWarning} - {optStyleHint, optStyleError}
-    of "error": conf.globalOptions = conf.globalOptions + {optStyleError} - {optStyleHint, optStyleWarning}
+    of "off": conf.globalOptions = conf.globalOptions - {optStyleHint, optStyleError}
+    of "hint": conf.globalOptions = conf.globalOptions + {optStyleHint} - {optStyleError}
+    of "error": conf.globalOptions = conf.globalOptions + {optStyleError}
     of "usages": conf.globalOptions.incl optStyleUsages
     else: localError(conf, info, errOffHintsError % arg)
   of "showallmismatches":

compiler/concepts.nim

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

compiler/condsyms.nim

@@ -171,8 +171,3 @@ proc initDefines*(symbols: StringTableRef) =
   defineSymbol("nimHasJsNoLambdaLifting")
   defineSymbol("nimHasDefaultFloatRoundtrip")
   defineSymbol("nimHasXorSet")
-
-  defineSymbol("nimHasPreviewDuplicateModuleError")
-  defineSymbol("nimHasSetLengthSeqUninitMagic")
-
-  defineSymbol("nimHasImplicitRangeConversion")

compiler/deps.nim

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

compiler/dfa.nim

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

compiler/docgen.nim

@@ -433,9 +433,6 @@ proc getVarIdx(varnames: openArray[string], id: string): int =
 
 proc genComment(d: PDoc, n: PNode): PRstNode =
   if n.comment.len > 0:
-    if optDocRaw in d.conf.globalOptions:
-      return newRstLeaf(n.comment)
-
     d.sharedState.currFileIdx = addRstFileIndex(d, n.info)
     try:
       result = parseRst(n.comment,
@@ -1179,12 +1176,8 @@ proc genJsonItem(d: PDoc, n, nameNode: PNode, k: TSymKind, nonExports = false):
                    "col": %n.info.col}
   )
   if comm != nil:
-    if optDocRaw in d.conf.globalOptions:
-      result.json["description"] = %comm.text
-    else:
-      result.rst = comm
-      result.rstField = "description"
-
+    result.rst = comm
+    result.rstField = "description"
   if r.buf.len > 0:
     result.json["code"] = %r.buf
   if k in routineKinds:
@@ -1413,19 +1406,16 @@ proc generateDoc*(d: PDoc, n, orig: PNode, config: ConfigRef, docFlags: DocFlags
     for it in n: traceDeps(d, it)
   of nkExportStmt:
     for it in n:
-      if it.kind == nkSym:
-        if d.module != nil and d.module == it.sym.owner:  # in current module
-          # bug #23051; don't generate documentation for exported symbols again
-          if sfExported notin it.sym.flags:
-            generateDoc(d, it.sym.ast, orig, config, kForceExport)
-          # else it's to be handled in `of XxxSection` branch
+      # bug #23051; don't generate documentation for exported symbols again
+      if it.kind == nkSym and sfExported notin it.sym.flags:
+        if d.module != nil and d.module == it.sym.owner:
+          generateDoc(d, it.sym.ast, orig, config, kForceExport)
         elif it.sym.ast != nil:
-          # only export symbols in imported modules, not in current module
           exportSym(d, it.sym)
   of nkExportExceptStmt: discard "transformed into nkExportStmt by semExportExcept"
   of nkFromStmt, nkImportExceptStmt: traceDeps(d, n[0])
   of nkCallKinds:
-    var comm = default(ItemPre)
+    var comm: ItemPre = default(ItemPre)
     getAllRunnableExamples(d, n, comm)
     if comm.len != 0: d.modDescPre.add(comm)
   else: discard
@@ -1899,9 +1889,6 @@ proc commandJson*(cache: IdentCache, conf: ConfigRef) =
   else:
     #echo getOutFile(gProjectFull, JsonExt)
     let filename = getOutFile(conf, RelativeFile conf.projectName, JsonExt)
-    conf.outFile = filename.relativeTo(conf.outDir)
-    let dir = filename.splitFile.dir
-    createDir(dir)
     try:
       writeFile(filename, content)
     except IOError:
@@ -1922,10 +1909,8 @@ proc commandTags*(cache: IdentCache, conf: ConfigRef) =
   if optStdout in d.conf.globalOptions:
     write(stdout, content)
   else:
+    #echo getOutFile(gProjectFull, TagsExt)
     let filename = getOutFile(conf, RelativeFile conf.projectName, TagsExt)
-    conf.outFile = filename.relativeTo(conf.outDir)
-    let dir = filename.splitFile.dir
-    createDir(dir)
     try:
       writeFile(filename, content)
     except IOError:

compiler/enumtostr.nim

@@ -33,10 +33,6 @@ proc genEnumToStrProc*(t: PType; info: TLineInfo; g: ModuleGraph; idgen: IdGener
     caseStmt.add newTree(nkOfBranch, newIntTypeNode(field.position, t),
       newTree(nkStmtList, newTree(nkFastAsgn, newSymNode(res), newStrNode(val, info))))
     #newIntTypeNode(nkIntLit, field.position, t)
-  # safety branch for invalid data:
-  caseStmt.add newTree(nkElse,
-    newTree(nkStmtList, newTree(nkFastAsgn, newSymNode(res),
-      newStrNode("", info))))
 
   body.add(caseStmt)
 

compiler/extccomp.nim

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

compiler/hlo.nim

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

compiler/importer.nim

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

compiler/injectdestructors.nim

@@ -100,7 +100,6 @@ when false:
 proc isLastReadImpl(n: PNode; c: var Con; scope: var Scope): bool =
   let root = parampatterns.exprRoot(n, allowCalls=false)
   if root == nil: return false
-  elif sfSingleUsedTemp in root.flags: return true
 
   var s = addr(scope)
   while s != nil:
@@ -163,16 +162,13 @@ proc isLastReadImpl(n: PNode; c: var Con; scope: var Scope): bool =
   else:
     result = false
 
-template hasDestructorOrAsgn(c: var Con, typ: PType): bool =
-  # bug #23354; an object type could have a non-trivial assignements when it is passed to a sink parameter
-  hasDestructor(c, typ) or (c.graph.config.selectedGC in {gcArc, gcOrc, gcAtomicArc} and
-        typ.kind == tyObject and not isTrivial(getAttachedOp(c.graph, typ, attachedAsgn)))
-
 proc isLastRead(n: PNode; c: var Con; s: var Scope): bool =
-  if not hasDestructorOrAsgn(c, n.typ): return true
+  # bug #23354; an object type could have a non-trival assignements when it is passed to a sink parameter
+  if not hasDestructor(c, n.typ) and (n.typ.kind != tyObject or isTrival(getAttachedOp(c.graph, n.typ, attachedAsgn))): return true
 
   let m = skipConvDfa(n)
-  result = isLastReadImpl(n, c, s)
+  result = (m.kind == nkSym and sfSingleUsedTemp in m.sym.flags) or
+      isLastReadImpl(n, c, s)
 
 proc isFirstWrite(n: PNode; c: var Con): bool =
   let m = skipConvDfa(n)
@@ -189,11 +185,10 @@ proc isCursor(n: PNode): bool =
   else:
     false
 
-template isFullyUnpackedTuple(n: PNode): bool =
+template isUnpackedTuple(n: PNode): bool =
   ## we move out all elements of unpacked tuples,
   ## hence unpacked tuples themselves don't need to be destroyed
   ## except it's already a cursor
-  ## restricted to `skTemp`, tuple temps where not every field is unpacked should not use `skTemp`
   (n.kind == nkSym and n.sym.kind == skTemp and
    n.sym.typ.kind == tyTuple and sfCursor notin n.sym.flags)
 
@@ -202,8 +197,7 @@ proc checkForErrorPragma(c: Con; t: PType; ri: PNode; opname: string; inferredFr
   if inferredFromCopy:
     m.add ", which is inferred from unavailable '=copy'"
 
-  if (opname == "=" or opname == "=copy" or opname == "=dup") and
-       ri != nil:
+  if (opname == "=" or opname == "=copy" or opname == "=dup") and ri != nil:
     m.add "; requires a copy because it's not the last read of '"
     m.add renderTree(ri)
     m.add '\''
@@ -253,12 +247,7 @@ proc genOp(c: var Con; t: PType; kind: TTypeAttachedOp; dest, ri: PNode): PNode
   dbg:
     if kind == attachedDestructor:
       echo "destructor is ", op.id, " ", op.ast
-  if sfError in op.flags:
-    if ri != nil:
-      checkForErrorPragma(c, t, ri, AttachedOpToStr[kind])
-    else:
-      # uses the lineinfos of `dest` is `ri` is not available
-      checkForErrorPragma(c, t, dest, AttachedOpToStr[kind])
+  if sfError in op.flags: checkForErrorPragma(c, t, ri, AttachedOpToStr[kind])
   c.genOp(op, dest)
 
 proc genDestroy(c: var Con; dest: PNode): PNode =
@@ -286,7 +275,7 @@ proc deepAliases(dest, ri: PNode): bool =
     return aliases(dest, ri) != no
 
 proc genSink(c: var Con; s: var Scope; dest, ri: PNode; flags: set[MoveOrCopyFlag] = {}): PNode =
-  if (c.inLoopCond == 0 and (isFullyUnpackedTuple(dest) or IsDecl in flags or
+  if (c.inLoopCond == 0 and (isUnpackedTuple(dest) or IsDecl in flags or
       (isAnalysableFieldAccess(dest, c.owner) and isFirstWrite(dest, c)))) or
       isNoInit(dest) or IsReturn in flags:
     # optimize sink call into a bitwise memcopy
@@ -411,7 +400,7 @@ proc genWasMoved(c: var Con, n: PNode): PNode =
     result = genOp(c, op, n)
   else:
     result = newNodeI(nkCall, n.info)
-    result.add(newSymNode(createMagic(c.graph, c.idgen, "wasMoved", mWasMoved)))
+    result.add(newSymNode(createMagic(c.graph, c.idgen, "`=wasMoved`", mWasMoved)))
     result.add copyTree(n) #mWasMoved does not take the address
     #if n.kind != nkSym:
     #  message(c.graph.config, n.info, warnUser, "wasMoved(" & $n & ")")
@@ -460,7 +449,7 @@ proc passCopyToSink(n: PNode; c: var Con; s: var Scope): PNode =
   result = newNodeIT(nkStmtListExpr, n.info, n.typ)
   let nTyp = n.typ.skipTypes(tyUserTypeClasses)
   let tmp = c.getTemp(s, nTyp, n.info)
-  if hasDestructorOrAsgn(c, nTyp):
+  if hasDestructor(c, nTyp):
     let typ = nTyp.skipTypes({tyGenericInst, tyAlias, tySink})
     let op = getAttachedOp(c.graph, typ, attachedDup)
     if op != nil and tfHasOwned notin typ.flags:
@@ -570,7 +559,7 @@ proc cycleCheck(n: PNode; c: var Con) =
 proc pVarTopLevel(v: PNode; c: var Con; s: var Scope; res: PNode) =
   # move the variable declaration to the top of the frame:
   s.vars.add v.sym
-  if isFullyUnpackedTuple(v):
+  if isUnpackedTuple(v):
     if c.inLoop > 0:
       # unpacked tuple needs reset at every loop iteration
       res.add newTree(nkFastAsgn, v, genDefaultCall(v.typ, c, v.info))
@@ -813,7 +802,15 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
       result = passCopyToSink(n, c, s)
     elif n.kind in {nkBracket, nkObjConstr, nkTupleConstr, nkClosure, nkNilLit} +
          nkCallKinds + nkLiterals:
-      result = p(n, c, s, consumed)
+      if n.kind in nkCallKinds and n[0].kind == nkSym:
+        if n[0].sym.magic == mEnsureMove:
+          inc c.inEnsureMove
+          result = p(n[1], c, s, sinkArg)
+          dec c.inEnsureMove
+        else:
+          result = p(n, c, s, consumed)
+      else:
+        result = p(n, c, s, consumed)
     elif ((n.kind == nkSym and isSinkParam(n.sym)) or isAnalysableFieldAccess(n, c.owner)) and
         isLastRead(n, c, s) and not (n.kind == nkSym and isCursor(n)):
       # Sinked params can be consumed only once. We need to reset the memory
@@ -889,6 +886,12 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
       if mode == normal and (isRefConstr or hasCustomDestructor(c, t)):
         result = ensureDestruction(result, n, c, s)
     of nkCallKinds:
+      if n[0].kind == nkSym and n[0].sym.magic == mEnsureMove:
+        inc c.inEnsureMove
+        result = p(n[1], c, s, sinkArg)
+        dec c.inEnsureMove
+        return
+
       let inSpawn = c.inSpawn
       if n[0].kind == nkSym and n[0].sym.magic == mSpawn:
         c.inSpawn.inc
@@ -906,19 +909,13 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
           isDangerous = true
 
       result = shallowCopy(n)
-
-      if n[0].kind == nkSym and n[0].sym.magic == mEnsureMove:
-        inc c.inEnsureMove
-        result[1] = p(n[1], c, s, sinkArg)
-        dec c.inEnsureMove
-      else:
-        for i in 1..<n.len:
-          if i < L and isCompileTimeOnly(parameters[i]):
-            result[i] = n[i]
-          elif i < L and (isSinkTypeForParam(parameters[i]) or inSpawn > 0):
-            result[i] = p(n[i], c, s, sinkArg)
-          else:
-            result[i] = p(n[i], c, s, normal)
+      for i in 1..<n.len:
+        if i < L and isCompileTimeOnly(parameters[i]):
+          result[i] = n[i]
+        elif i < L and (isSinkTypeForParam(parameters[i]) or inSpawn > 0):
+          result[i] = p(n[i], c, s, sinkArg)
+        else:
+          result[i] = p(n[i], c, s, normal)
 
       when false:
         if isDangerous:
@@ -946,9 +943,6 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
     of nkVarSection, nkLetSection:
       # transform; var x = y to  var x; x op y  where op is a move or copy
       result = newNodeI(nkStmtList, n.info)
-
-      let isInProc = c.owner.kind in {skProc, skFunc, skMethod, skIterator, skConverter}
-
       for it in n:
         var ri = it[^1]
         if it.kind == nkVarTuple and hasDestructor(c, ri.typ):
@@ -964,15 +958,7 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
               s.locals.add v.sym
               pVarTopLevel(v, c, s, result)
             if ri.kind != nkEmpty:
-              let isGlobalPragma = v.kind == nkSym and 
-                      {sfPure, sfGlobal} <= v.sym.flags and
-                      isInProc
-
-              if isGlobalPragma:
-                c.graph.procGlobals.add newTree(nkFastAsgn, v, ri)
-              else:
-                let value = moveOrCopy(v, ri, c, s, if v.kind == nkSym: {IsDecl} else: {})
-                result.add value
+              result.add moveOrCopy(v, ri, c, s, if v.kind == nkSym: {IsDecl} else: {})
             elif ri.kind == nkEmpty and c.inLoop > 0:
               let skipInit = v.kind == nkDotExpr and # Closure var
                              sfNoInit in v[1].sym.flags
@@ -1144,25 +1130,6 @@ proc genFieldAccessSideEffects(c: var Con; s: var Scope; dest, ri: PNode; flags:
   var snk = c.genSink(s, dest, newAccess, flags)
   result = newTree(nkStmtList, v, snk, c.genWasMoved(newAccess))
 
-proc ownsData(c: var Con; s: var Scope; orig: PNode; flags: set[MoveOrCopyFlag]): PNode =
-  var n = orig
-  while true:
-    case n.kind
-    of nkDotExpr, nkCheckedFieldExpr, nkBracketExpr:
-      n = n[0]
-    else:
-      break
-  if n.kind in nkCallKinds and n.typ != nil and hasDestructor(c, n.typ):
-    result = newNodeIT(nkStmtListExpr, orig.info, orig.typ)
-    let tmp = c.getTemp(s, n.typ, n.info)
-    tmp.sym.flags.incl sfSingleUsedTemp
-    result.add newTree(nkFastAsgn, tmp, copyTree(n))
-    s.final.add c.genDestroy(tmp)
-    n[] = tmp[]
-    result.add copyTree(orig)
-  else:
-    result = nil
-
 proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopyFlag] = {}): PNode =
   var ri = ri
   var isEnsureMove = 0
@@ -1189,7 +1156,7 @@ proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopy
     of nkCallKinds:
       result = c.genSink(s, dest, p(ri, c, s, consumed), flags)
     of nkBracketExpr:
-      if isFullyUnpackedTuple(ri[0]):
+      if isUnpackedTuple(ri[0]):
         # unpacking of tuple: take over the elements
         result = c.genSink(s, dest, p(ri, c, s, consumed), flags)
       elif isAnalysableFieldAccess(ri, c.owner) and isLastRead(ri, c, s):
@@ -1238,22 +1205,15 @@ proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopy
         result.add p(ri, c, s, consumed)
         c.finishCopy(result, dest, flags, isFromSink = false)
     of nkHiddenSubConv, nkHiddenStdConv, nkConv, nkObjDownConv, nkObjUpConv, nkCast:
-      if IsExplicitSink in flags:
-        result = c.genSink(s, dest, p(ri, c, s, consumed), flags)
-      else:
-        result = c.genSink(s, dest, p(ri, c, s, sinkArg), flags)
-    of nkStmtListExpr, nkBlockExpr, nkIfExpr, nkCaseStmt, nkTryStmt, nkPragmaBlock:
+      result = c.genSink(s, dest, p(ri, c, s, sinkArg), flags)
+    of nkStmtListExpr, nkBlockExpr, nkIfExpr, nkCaseStmt, nkTryStmt:
       template process(child, s): untyped = moveOrCopy(dest, child, c, s, flags)
       # We know the result will be a stmt so we use that fact to optimize
       handleNestedTempl(ri, process, willProduceStmt = true)
     of nkRaiseStmt:
       result = pRaiseStmt(ri, c, s)
     else:
-      let isOwnsData = ownsData(c, s, ri2, flags)
-
-      if isOwnsData != nil:
-        result = moveOrCopy(dest, isOwnsData, c, s, flags)
-      elif isAnalysableFieldAccess(ri, c.owner) and isLastRead(ri, c, s) and
+      if isAnalysableFieldAccess(ri, c.owner) and isLastRead(ri, c, s) and
           canBeMoved(c, dest.typ):
         # Rule 3: `=sink`(x, z); wasMoved(z)
         let snk = c.genSink(s, dest, ri, flags)

compiler/installer.ini

@@ -6,7 +6,7 @@ Name: "Nim"
 Version: "$version"
 Platforms: """
   windows: i386;amd64
-  linux: i386;hppa;ia64;alpha;amd64;powerpc64;arm;sparc;sparc64;s390x;m68k;mips;mipsel;mips64;mips64el;powerpc;powerpc64el;arm64;riscv32;riscv64;loongarch64
+  linux: i386;hppa;ia64;alpha;amd64;powerpc64;arm;sparc;sparc64;m68k;mips;mipsel;mips64;mips64el;powerpc;powerpc64el;arm64;riscv32;riscv64;loongarch64
   macosx: i386;amd64;powerpc64;arm64
   solaris: i386;amd64;sparc;sparc64
   freebsd: i386;amd64;powerpc64;arm;arm64;riscv64;sparc64;mips;mipsel;mips64;mips64el;powerpc;powerpc64el

compiler/isolation_check.nim

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

compiler/jsgen.nim

@@ -728,47 +728,44 @@ proc arithAux(p: PProc, n: PNode, r: var TCompRes, op: TMagic) =
   of mShrI:
     let typ = n[1].typ.skipTypes(abstractVarRange)
     if typ.kind == tyInt64 and optJsBigInt64 in p.config.globalOptions:
-      applyFormat("BigInt.asIntN(64, BigInt.asUintN(64, $1) >> (BigInt($2) & 63n))")
+      applyFormat("BigInt.asIntN(64, BigInt.asUintN(64, $1) >> BigInt($2))")
     elif typ.kind == tyUInt64 and optJsBigInt64 in p.config.globalOptions:
-      applyFormat("($1 >> (BigInt($2) & 63n))")
+      applyFormat("($1 >> BigInt($2))")
     else:
-      let bitmask = typ.size * 8 - 1
       if typ.kind in {tyInt..tyInt32}:
         let trimmerU = unsignedTrimmer(typ.size)
         let trimmerS = signedTrimmer(typ.size)
-        r.res = "((($1 $2) >>> ($3 & $5)) $4)" % [xLoc, trimmerU, yLoc, trimmerS, $bitmask]
+        r.res = "((($1 $2) >>> $3) $4)" % [xLoc, trimmerU, yLoc, trimmerS]
       else:
-        r.res = "($1 >>> ($2 & $3))" % [xLoc, yLoc, $bitmask]
+        applyFormat("($1 >>> $2)")
   of mShlI:
     let typ = n[1].typ.skipTypes(abstractVarRange)
     if typ.size == 8:
       if typ.kind == tyInt64 and optJsBigInt64 in p.config.globalOptions:
-        applyFormat("BigInt.asIntN(64, $1 << (BigInt($2) & 63n))")
+        applyFormat("BigInt.asIntN(64, $1 << BigInt($2))")
       elif typ.kind == tyUInt64 and optJsBigInt64 in p.config.globalOptions:
-        applyFormat("BigInt.asUintN(64, $1 << (BigInt($2) & 63n))")
+        applyFormat("BigInt.asUintN(64, $1 << BigInt($2))")
       else:
-        applyFormat("($1 * Math.pow(2, ($2 & 63)))")
+        applyFormat("($1 * Math.pow(2, $2))")
     else:
-      let bitmask = typ.size * 8 - 1
       if typ.kind in {tyUInt..tyUInt32}:
         let trimmer = unsignedTrimmer(typ.size)
-        r.res = "(($1 << ($2 & $4)) $3)" % [xLoc, yLoc, trimmer, $bitmask]
+        r.res = "(($1 << $2) $3)" % [xLoc, yLoc, trimmer]
       else:
         let trimmer = signedTrimmer(typ.size)
-        r.res = "(($1 << ($2 & $4)) $3)" % [xLoc, yLoc, trimmer, $bitmask]
+        r.res = "(($1 << $2) $3)" % [xLoc, yLoc, trimmer]
   of mAshrI:
     let typ = n[1].typ.skipTypes(abstractVarRange)
     if typ.size == 8:
       if optJsBigInt64 in p.config.globalOptions:
-        applyFormat("($1 >> (BigInt($2) & 63n))")
+        applyFormat("($1 >> BigInt($2))")
       else:
-        applyFormat("Math.floor($1 / Math.pow(2, ($2 & 63)))")
+        applyFormat("Math.floor($1 / Math.pow(2, $2))")
     else:
-      let bitmask = typ.size * 8 - 1
       if typ.kind in {tyUInt..tyUInt32}:
-        r.res = "($1 >>> ($2 & $3)))" % [xLoc, yLoc, $bitmask]
+        applyFormat("($1 >>> $2)")
       else:
-        r.res = "($1 >> ($2 & $3))" % [xLoc, yLoc, $bitmask]
+        applyFormat("($1 >> $2)")
   of mBitandI: bitwiseExpr("&")
   of mBitorI: bitwiseExpr("|")
   of mBitxorI: bitwiseExpr("^")
@@ -1374,8 +1371,7 @@ proc genFieldAddr(p: PProc, n: PNode, r: var TCompRes) =
   r.typ = etyBaseIndex
   let b = if n.kind == nkHiddenAddr: n[0] else: n
   gen(p, b[0], a)
-  if skipTypes(b[0].typ, abstractVarRange + tyTypeClasses).kind == tyTuple:
-    # ref #25227 about `+ tyTypeClasses`
+  if skipTypes(b[0].typ, abstractVarRange).kind == tyTuple:
     r.res = makeJSString("Field" & $getFieldPosition(p, b[1]))
   else:
     if b[1].kind != nkSym: internalError(p.config, b[1].info, "genFieldAddr")
@@ -1589,12 +1585,15 @@ proc genAddr(p: PProc, n: PNode, r: var TCompRes) =
         else: internalError(p.config, n[0].info, "expr(nkBracketExpr, " & $kindOfIndexedExpr & ')')
     of nkObjDownConv:
       gen(p, n[0], r)
-    of nkHiddenDeref, nkDerefExpr:
-      if n.kind in {nkAddr, nkHiddenAddr}:
-        # addr ( deref ( x )) --> x
-        gen(p, n[0][0], r)
-      else:
-        gen(p, n[0], r)
+    of nkHiddenDeref:
+      gen(p, n[0], r)
+    of nkDerefExpr:
+      var x = n[0]
+      if n.kind == nkHiddenAddr:
+        x = n[0][0]
+        if n.typ.skipTypes(abstractVar).kind != tyOpenArray:
+          x.typ() = n.typ
+      gen(p, x, r)
     of nkHiddenAddr:
       gen(p, n[0], r)
     of nkConv:
@@ -2337,8 +2336,8 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
       r.res = "if (null != $1) { if (null == $2) $2 = $3; else $2 += $3; }" %
         [b, lhs.rdLoc, tmp]
     else:
-      useMagic(p, "nimAddStrStr")
-      r.res = "nimAddStrStr($1, $2);" % [lhs.rdLoc, rhs.rdLoc]
+      let (a, tmp) = maybeMakeTemp(p, n[1], lhs)
+      r.res = "$1.push.apply($3, $2);" % [a, rhs.rdLoc, tmp]
     r.kind = resExpr
   of mAppendSeqElem:
     var x, y: TCompRes = default(TCompRes)
@@ -2442,7 +2441,7 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
     binaryExpr(p, n, r, "mnewString",
       """if ($1.length < $2) { for (var i = $3.length; i < $4; ++i) $3.push(0); }
          else {$3.length = $4; }""")
-  of mSetLengthSeq, mSetLengthSeqUninit:
+  of mSetLengthSeq:
     var x, y: TCompRes = default(TCompRes)
     gen(p, n[1], x)
     gen(p, n[2], y)
@@ -2883,8 +2882,6 @@ proc genCast(p: PProc, n: PNode, r: var TCompRes) =
   elif dest.kind in tyFloat..tyFloat64:
     if src.kind in {tyInt64, tyUInt64} and optJsBigInt64 in p.config.globalOptions:
       r.res = "Number($1)" % [r.res]
-  elif dest.kind == tyChar and (fromInt or fromUint):
-    r.res = "($1 & 255)" % [r.res]
   elif (src.kind == tyPtr and mapType(p, src) == etyObject) and dest.kind == tyPointer:
     r.address = r.res
     r.res = "null"

compiler/jstypes.nim

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

compiler/lambdalifting.nim

@@ -150,7 +150,6 @@ template isIterator*(owner: PSym): bool =
 
 proc createEnvObj(g: ModuleGraph; idgen: IdGenerator; owner: PSym; info: TLineInfo): PType =
   result = createObj(g, idgen, owner, info, final=false)
-  result.flags.incl tfFinal
   if owner.isIterator:
     rawAddField(result, createStateField(g, owner, idgen))
 
@@ -200,7 +199,7 @@ proc interestingVar(s: PSym): bool {.inline.} =
 proc illegalCapture(s: PSym): bool {.inline.} =
   result = classifyViewType(s.typ) != noView or s.kind == skResult
 
-proc isInnerProc*(s: PSym): bool =
+proc isInnerProc(s: PSym): bool =
   if s.kind in {skProc, skFunc, skMethod, skConverter, skIterator} and s.magic == mNone:
     result = s.skipGenericOwner.kind in routineKinds
   else:
@@ -975,20 +974,6 @@ proc liftForLoop*(g: ModuleGraph; body: PNode; idgen: IdGenerator; owner: PSym):
       for i in 0..<op.len-1:
         result.add op[i]
 
-  elif op.kind != nkSym: # might have side effects
-    # bug #25046
-    # create a temp for the closure
-    # var :closureTemp
-    # :closureTemp = ...
-    let tempSym = newSym(skLet, getIdent(g.cache, ":closureTemp"), idgen, owner, body.info)
-    tempSym.typ = call[0].typ
-    let temp = newSymNode(tempSym)
-    var v = newNodeI(nkVarSection, body.info)
-    addVar(v, temp)
-    result.add(v)
-    result.add newAsgnStmt(temp, call[0], body.info)
-    call[0] = temp
-
   var loopBody = newNodeI(nkStmtList, body.info, 3)
   var whileLoop = newNodeI(nkWhileStmt, body.info, 2)
   whileLoop[0] = newIntTypeNode(1, getSysType(g, body.info, tyBool))

compiler/layeredtable.nim

@@ -1,4 +1,5 @@
-import ast, astalgo
+import std/tables
+import ast
 
 type
   LayeredIdTableObj* {.acyclic.} = object
@@ -27,15 +28,14 @@ proc shallowCopy*(pt: LayeredIdTable): LayeredIdTable {.inline.} =
   ## copies only the type bindings of the current layer, but not any parent layers,
   ## useful for write-only bindings
   result = LayeredIdTable(topLayer: pt.topLayer, nextLayer: pt.nextLayer, previousLen: pt.previousLen)
-  #copyIdTable(result.topLayer, pt.topLayer)
 
 proc currentLen*(pt: LayeredIdTable): int =
   ## the sum of the cached total binding count of the parents and
   ## the current binding count, just used to track if bindings were added
-  pt.previousLen + pt.topLayer.counter
+  pt.previousLen + pt.topLayer.len
 
 proc newTypeMapLayer*(pt: LayeredIdTable): LayeredIdTable =
-  result = LayeredIdTable(topLayer: initTypeMapping(), previousLen: pt.currentLen)
+  result = LayeredIdTable(topLayer: initTable[ItemId, PType](), previousLen: pt.currentLen)
   when useRef:
     result.nextLayer = pt
   else:
@@ -53,15 +53,6 @@ proc setToPreviousLayer*(pt: var LayeredIdTable) {.inline.} =
       let tmp = pt.nextLayer[]
       pt = tmp
 
-iterator pairs*(pt: LayeredIdTable): (ItemId, PType) =
-  var tm = pt
-  while true:
-    for (k, v) in idTablePairs(tm.topLayer):
-      yield (k, v)
-    if tm.nextLayer == nil:
-      break
-    tm.setToPreviousLayer
-
 proc lookup(typeMap: ref LayeredIdTableObj, key: ItemId): PType =
   result = nil
   var tm = typeMap

compiler/lexer.nim

@@ -316,28 +316,6 @@ proc getNumber(L: var Lexer, result: var Token) =
     L.bufpos = msgPos
     lexMessage(L, msgKind, msg % t.literal)
 
-  proc checkBitWidth(L: var Lexer, base: NumericalBase, tokType: TokType, 
-                     numDigits: int, startpos: int) =
-    # Check bit width for non-base-10 literals
-    # Warn if the digit count exceeds what can fit in the target type
-    let bitsPerDigit = case base
-      of base2: 1
-      of base8: 3
-      of base16: 4
-      else: raiseAssert "unreachable"
-    let bitWidth = case tokType
-      of tkInt8Lit, tkUInt8Lit: 8
-      of tkInt16Lit, tkUInt16Lit: 16
-      of tkInt32Lit, tkUInt32Lit: 32
-      of tkInt64Lit, tkUIntLit, tkIntLit, tkUInt64Lit: 64
-      else: raiseAssert "unreachable"
-    # Maximum digits = ceil(bitWidth / bitsPerDigit) = (bitWidth + bitsPerDigit - 1) div bitsPerDigit
-    let maxDigits = (bitWidth + bitsPerDigit - 1) div bitsPerDigit
-    if numDigits > maxDigits:
-      lexMessageLitNum(L,
-        "number has " & $numDigits & " digits but type only supports " &
-        $maxDigits & " digits: '$1'", startpos, warnLongLiterals)
-
   var
     xi: BiggestInt
     isBase10 = true
@@ -513,11 +491,6 @@ proc getNumber(L: var Lexer, result: var Token) =
           setNumber result.fNumber, (cast[ptr float64](addr(xi)))[]
         else: internalError(L.config, getLineInfo(L), "getNumber")
 
-        # Check bit width for non-base-10 literals
-        # Warn if the digit count exceeds what can fit in the target type
-        if result.base != base10 and result.tokType in {tkIntLit..tkUInt64Lit} and numDigits > 0:
-          checkBitWidth(L, result.base, result.tokType, numDigits, startpos)
-
         # Bounds checks. Non decimal literals are allowed to overflow the range of
         # the datatype as long as their pattern don't overflow _bitwise_, hence
         # below checks of signed sizes against uint*.high is deliberate:
@@ -923,7 +896,7 @@ proc getSymbol(L: var Lexer, tok: var Token) =
     tok.tokType = tkSymbol
   else:
     tok.tokType = TokType(tok.ident.id + ord(tkSymbol))
-    if suspicious and {optStyleHint, optStyleError, optStyleWarning} * L.config.globalOptions != {}:
+    if suspicious and {optStyleHint, optStyleError} * L.config.globalOptions != {}:
       lintReport(L.config, getLineInfo(L), tok.ident.s.normalize, tok.ident.s)
   L.bufpos = pos
 

compiler/liftdestructors.nim

@@ -40,7 +40,7 @@ template asink*(t: PType): PSym = getAttachedOp(c.g, t, attachedSink)
 
 proc fillBody(c: var TLiftCtx; t: PType; body, x, y: PNode)
 proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
-              info: TLineInfo; idgen: IdGenerator): PSym
+              info: TLineInfo; idgen: IdGenerator; isDistinct = false): PSym
 
 proc createTypeBoundOps*(g: ModuleGraph; c: PContext; orig: PType; info: TLineInfo;
                          idgen: IdGenerator)
@@ -91,7 +91,7 @@ proc defaultOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     call.typ() = t
     body.add newAsgnStmt(x, call)
   elif c.kind == attachedWasMoved:
-    body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+    body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc genAddr(c: var TLiftCtx; x: PNode): PNode =
   if x.kind == nkHiddenDeref:
@@ -148,7 +148,7 @@ proc destructorCall(c: var TLiftCtx; op: PSym; x: PNode): PNode =
   if sfNeverRaises notin op.flags:
     c.canRaise = true
   if c.addMemReset:
-    result = newTree(nkStmtList, destroy, genBuiltin(c, mWasMoved,  "wasMoved", x))
+    result = newTree(nkStmtList, destroy, genBuiltin(c, mWasMoved,  "`=wasMoved`", x))
   else:
     result = destroy
 
@@ -168,7 +168,7 @@ proc fillBodyObj(c: var TLiftCtx; n, body, x, y: PNode; enforceDefaultOp: bool,
       defaultOp(c, f.typ, body, x.dotField(f), b)
     else:
       if enforceWasMoved:
-        body.add genBuiltin(c, mWasMoved, "wasMoved", x.dotField(f))
+        body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x.dotField(f))
       fillBody(c, f.typ, body, x.dotField(f), b)
   of nkNilLit: discard
   of nkRecCase:
@@ -218,38 +218,23 @@ proc fillBodyObj(c: var TLiftCtx; n, body, x, y: PNode; enforceDefaultOp: bool,
       fillBodyObj(c, n[0], body, x, y, enforceDefaultOp = false)
     c.filterDiscriminator = oldfilterDiscriminator
   of nkRecList:
-    # destroys in reverse order #24719
-    if c.kind == attachedDestructor:
-      for i in countdown(n.len-1, 0):
-        fillBodyObj(c, n[i], body, x, y, enforceDefaultOp, enforceWasMoved)
-    else:
-      for t in items(n): fillBodyObj(c, t, body, x, y, enforceDefaultOp, enforceWasMoved)
+    for t in items(n): fillBodyObj(c, t, body, x, y, enforceDefaultOp, enforceWasMoved)
   else:
     illFormedAstLocal(n, c.g.config)
 
 proc fillBodyObjTImpl(c: var TLiftCtx; t: PType, body, x, y: PNode) =
-  template fillBase =
-    if t.baseClass != nil:
-      let dest = newNodeIT(nkHiddenSubConv, c.info, t.baseClass)
-      dest.add newNodeI(nkEmpty, c.info)
-      dest.add x
-      var src = y
-      if c.kind in {attachedAsgn, attachedDeepCopy, attachedSink}:
-        src = newNodeIT(nkHiddenSubConv, c.info, t.baseClass)
-        src.add newNodeI(nkEmpty, c.info)
-        src.add y
+  if t.baseClass != nil:
+    let dest = newNodeIT(nkHiddenSubConv, c.info, t.baseClass)
+    dest.add newNodeI(nkEmpty, c.info)
+    dest.add x
+    var src = y
+    if c.kind in {attachedAsgn, attachedDeepCopy, attachedSink}:
+      src = newNodeIT(nkHiddenSubConv, c.info, t.baseClass)
+      src.add newNodeI(nkEmpty, c.info)
+      src.add y
 
-      fillBody(c, skipTypes(t.baseClass, abstractPtrs), body, dest, src)
-  template fillFields =
-    fillBodyObj(c, t.n, body, x, y, enforceDefaultOp = false)
-
-  if c.kind == attachedDestructor:
-    # destroys in reverse order #24719
-    fillFields()
-    fillBase()
-  else:
-    fillBase()
-    fillFields()
+    fillBody(c, skipTypes(t.baseClass, abstractPtrs), body, dest, src)
+  fillBodyObj(c, t.n, body, x, y, enforceDefaultOp = false)
 
 proc fillBodyObjT(c: var TLiftCtx; t: PType, body, x, y: PNode) =
   var hasCase = isCaseObj(t.n)
@@ -292,8 +277,7 @@ proc fillBodyObjT(c: var TLiftCtx; t: PType, body, x, y: PNode) =
     #body.add newAsgnStmt(blob, x)
 
     var wasMovedCall = newNodeI(nkCall, c.info)
-    wasMovedCall.add(newSymNode(createMagic(c.g, c.idgen, "wasMoved", mWasMoved)))
-
+    wasMovedCall.add(newSymNode(createMagic(c.g, c.idgen, "`=wasMoved`", mWasMoved)))
     wasMovedCall.add x # mWasMoved does not take the address
     body.add wasMovedCall
 
@@ -380,10 +364,6 @@ proc requiresDestructor(c: TLiftCtx; t: PType): bool {.inline.} =
 proc instantiateGeneric(c: var TLiftCtx; op: PSym; t, typeInst: PType): PSym =
   if c.c != nil and typeInst != nil:
     result = c.c.instTypeBoundOp(c.c, op, typeInst, c.info, attachedAsgn, 1)
-  elif typeInst != nil and getAttachedOp(c.g, typeInst, c.kind) != nil:
-    # c.c == nil in lambdalifting
-    # hooks are already insted
-    result = getAttachedOp(c.g, typeInst, c.kind)
   else:
     localError(c.g.config, c.info,
       "cannot generate destructor for generic type: " & typeToString(t))
@@ -632,7 +612,7 @@ proc fillSeqOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     if canFormAcycle(c.g, t.elemType):
       # follow all elements:
       forallElements(c, t, body, x, y)
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc useSeqOrStrOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   createTypeBoundOps(c.g, c.c, t, body.info, c.idgen)
@@ -670,7 +650,7 @@ proc useSeqOrStrOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
       if op == nil:
         return # protect from recursion
       body.add newHookCall(c, op, x, y)
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
   of attachedDup:
     # XXX: replace these with assertions.
     let op = getAttachedOp(c.g, t, c.kind)
@@ -692,7 +672,7 @@ proc fillStrOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     body.add genBuiltin(c, mDestroy, "destroy", x)
   of attachedTrace:
     discard "strings are atomic and have no inner elements that are to trace"
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc cyclicType*(g: ModuleGraph, t: PType): bool =
   case t.kind
@@ -791,7 +771,7 @@ proc atomicRefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
         # If the ref is polymorphic we have to account for this
         body.add callCodegenProc(c.g, "nimTraceRefDyn", c.info, genAddrOf(x, c.idgen), y)
       #echo "can follow ", elemType, " static ", isFinal(elemType)
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
   of attachedDup:
     if isCyclic:
       body.add newAsgnStmt(x, y)
@@ -858,7 +838,7 @@ proc atomicClosureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   of attachedDeepCopy: assert(false, "cannot happen")
   of attachedTrace:
     body.add callCodegenProc(c.g, "nimTraceRefDyn", c.info, genAddrOf(xenv, c.idgen), y)
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc weakrefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   case c.kind
@@ -886,7 +866,7 @@ proc weakrefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
       body.sons.insert(des, 0)
   of attachedDeepCopy: assert(false, "cannot happen")
   of attachedTrace: discard
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc ownedRefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   var actions = newNodeI(nkStmtList, c.info)
@@ -914,7 +894,7 @@ proc ownedRefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     body.add genIf(c, x, actions)
   of attachedDeepCopy: assert(false, "cannot happen")
   of attachedTrace: discard
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc closureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   if c.kind == attachedDeepCopy:
@@ -954,7 +934,7 @@ proc closureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
         body.sons.insert(des, 0)
     of attachedDeepCopy: assert(false, "cannot happen")
     of attachedTrace: discard
-    of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+    of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc ownedClosureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   let xx = genBuiltin(c, mAccessEnv, "accessEnv", x)
@@ -972,7 +952,7 @@ proc ownedClosureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     body.add genIf(c, xx, actions)
   of attachedDeepCopy: assert(false, "cannot happen")
   of attachedTrace: discard
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc fillBody(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   case t.kind
@@ -1022,13 +1002,9 @@ proc fillBody(c: var TLiftCtx; t: PType; body, x, y: PNode) =
       # 'selectedGC' here to determine if we have the new runtime.
       discard considerUserDefinedOp(c, t, body, x, y)
     elif tfHasAsgn in t.flags:
-      # seqs with elements using custom hooks in refc
       if c.kind in {attachedAsgn, attachedSink, attachedDeepCopy}:
         body.add newSeqCall(c, x, y)
-      if c.kind == attachedWasMoved:
-        body.add genBuiltin(c, mWasMoved, "wasMoved", x)
-      else:
-        forallElements(c, t, body, x, y)
+      forallElements(c, t, body, x, y)
     else:
       defaultOp(c, t, body, x, y)
   of tyString:
@@ -1045,11 +1021,9 @@ proc fillBody(c: var TLiftCtx; t: PType; body, x, y: PNode) =
         of {attachedAsgn, attachedSink, attachedDup}:
           body.add newAsgnStmt(x, y)
         of attachedWasMoved:
-          body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+          body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
         else:
           fillBodyObjT(c, t, body, x, y)
-      elif tfUnion in t.flags: # bug #25236
-        defaultOp(c, t, body, x, y)
       else:
         if c.kind == attachedDup:
           var op2 = getAttachedOp(c.g, t, attachedAsgn)
@@ -1089,7 +1063,9 @@ proc produceSymDistinctType(g: ModuleGraph; c: PContext; typ: PType;
   assert typ.kind == tyDistinct
   let baseType = typ.elementType
   if getAttachedOp(g, baseType, kind) == nil:
-    discard produceSym(g, c, baseType, kind, info, idgen)
+    # TODO: fixme `isDistinct` is a fix for #23552; remove it after
+    # `-d:nimPreviewNonVarDestructor` becomes the default
+    discard produceSym(g, c, baseType, kind, info, idgen, isDistinct = true)
   result = getAttachedOp(g, baseType, kind)
   setAttachedOp(g, idgen.module, typ, kind, result)
 
@@ -1128,7 +1104,7 @@ proc symDupPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttache
   incl result.flags, sfGeneratedOp
 
 proc symPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttachedOp;
-              info: TLineInfo; idgen: IdGenerator; isDiscriminant = false): PSym =
+              info: TLineInfo; idgen: IdGenerator; isDiscriminant = false; isDistinct = false): PSym =
   if kind == attachedDup:
     return symDupPrototype(g, typ, owner, kind, info, idgen)
 
@@ -1139,7 +1115,7 @@ proc symPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttachedOp
                    idgen, result, info)
 
   if kind == attachedDestructor and g.config.selectedGC in {gcArc, gcOrc, gcAtomicArc} and
-     ((g.config.isDefined("nimPreviewNonVarDestructor") and not isDiscriminant) or (typ.kind in {tyRef, tyString, tySequence})):
+     ((g.config.isDefined("nimPreviewNonVarDestructor") and not isDiscriminant) or (typ.kind in {tyRef, tyString, tySequence} and not isDistinct)):
     dest.typ = typ
   else:
     dest.typ = makeVarType(typ.owner, typ, idgen)
@@ -1181,13 +1157,13 @@ proc genTypeFieldCopy(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   body.add newAsgnStmt(xx, yy)
 
 proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
-              info: TLineInfo; idgen: IdGenerator): PSym =
+              info: TLineInfo; idgen: IdGenerator; isDistinct = false): PSym =
   if typ.kind == tyDistinct:
     return produceSymDistinctType(g, c, typ, kind, info, idgen)
 
   result = getAttachedOp(g, typ, kind)
   if result == nil:
-    result = symPrototype(g, typ, typ.owner, kind, info, idgen)
+    result = symPrototype(g, typ, typ.owner, kind, info, idgen, isDistinct = isDistinct)
 
   var a = TLiftCtx(info: info, g: g, kind: kind, c: c, asgnForType: typ, idgen: idgen,
                    fn: result)
@@ -1210,10 +1186,8 @@ proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
     result.ast[bodyPos].add newAsgnStmt(d, src)
   else:
     var tk: TTypeKind
-    var skipped: PType = nil
     if g.config.selectedGC in {gcArc, gcOrc, gcHooks, gcAtomicArc}:
-      skipped = skipTypes(typ, {tyOrdinal, tyRange, tyInferred, tyGenericInst, tyStatic, tyAlias, tySink})
-      tk = skipped.kind
+      tk = skipTypes(typ, {tyOrdinal, tyRange, tyInferred, tyGenericInst, tyStatic, tyAlias, tySink}).kind
     else:
       tk = tyNone # no special casing for strings and seqs
     case tk
@@ -1223,7 +1197,7 @@ proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
       fillStrOp(a, typ, result.ast[bodyPos], d, src)
     else:
       fillBody(a, typ, result.ast[bodyPos], d, src)
-      if tk == tyObject and a.kind in {attachedAsgn, attachedSink, attachedDeepCopy, attachedDup} and not isObjLackingTypeField(skipped):
+      if tk == tyObject and a.kind in {attachedAsgn, attachedSink, attachedDeepCopy, attachedDup} and not lacksMTypeField(typ):
         # bug #19205: Do not forget to also copy the hidden type field:
         genTypeFieldCopy(a, typ, result.ast[bodyPos], d, src)
 
@@ -1233,8 +1207,6 @@ proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
     result.ast[pragmasPos].add newTree(nkExprColonExpr,
         newIdentNode(g.cache.getIdent("raises"),  info), newNodeI(nkBracket, info))
 
-  if kind == attachedDestructor:
-    incl result.options, optQuirky
   completePartialOp(g, idgen.module, typ, kind, result)
 
 
@@ -1294,7 +1266,7 @@ proc inst(g: ModuleGraph; c: PContext; t: PType; kind: TTypeAttachedOp; idgen: I
     else:
       localError(g.config, info, "unresolved generic parameter")
 
-proc isTrivial*(s: PSym): bool {.inline.} =
+proc isTrival*(s: PSym): bool {.inline.} =
   s == nil or (s.ast != nil and s.ast[bodyPos].len == 0)
 
 proc createTypeBoundOps(g: ModuleGraph; c: PContext; orig: PType; info: TLineInfo;
@@ -1304,10 +1276,6 @@ proc createTypeBoundOps(g: ModuleGraph; c: PContext; orig: PType; info: TLineInf
   ## The later 'injectdestructors' pass depends on it.
   if orig == nil or {tfCheckedForDestructor, tfHasMeta} * orig.flags != {}: return
   incl orig.flags, tfCheckedForDestructor
-  # for user defined generic destructors:
-  let origRoot = genericRoot(orig)
-  if origRoot != nil:
-    incl origRoot.flags, tfGenericHasDestructor
 
   let skipped = orig.skipTypes({tyGenericInst, tyAlias, tySink})
   if isEmptyContainer(skipped) or skipped.kind == tyStatic: return
@@ -1349,8 +1317,8 @@ proc createTypeBoundOps(g: ModuleGraph; c: PContext; orig: PType; info: TLineInf
     if canon != orig:
       setAttachedOp(g, idgen.module, orig, k, getAttachedOp(g, canon, k))
 
-  if not isTrivial(getAttachedOp(g, orig, attachedDestructor)):
-    #or not isTrivial(orig.assignment) or
-    # not isTrivial(orig.sink):
+  if not isTrival(getAttachedOp(g, orig, attachedDestructor)):
+    #or not isTrival(orig.assignment) or
+    # not isTrival(orig.sink):
     orig.flags.incl tfHasAsgn
     # ^ XXX Breaks IC!

compiler/lineinfos.nim

@@ -93,12 +93,9 @@ type
     warnBareExcept = "BareExcept",
     warnImplicitDefaultValue = "ImplicitDefaultValue",
     warnIgnoredSymbolInjection = "IgnoredSymbolInjection",
-    warnStdPrefix = "StdPrefix",
-    warnUnknownNotes = "UnknownNotes",
-    warnLongLiterals = "LongLiterals",
+    warnStdPrefix = "StdPrefix"
     warnUser = "User",
     warnGlobalVarConstructorTemporary = "GlobalVarConstructorTemporary",
-    warnImplicitRangeConversion = "ImplicitRangeConversion",
     # hints
     hintSuccess = "Success", hintSuccessX = "SuccessX",
     hintCC = "CC",
@@ -112,9 +109,9 @@ type
     hintSource = "Source", hintPerformance = "Performance", hintStackTrace = "StackTrace",
     hintGCStats = "GCStats", hintGlobalVar = "GlobalVar", hintExpandMacro = "ExpandMacro",
     hintUser = "User", hintUserRaw = "UserRaw", hintExtendedContext = "ExtendedContext",
-    hintUnknownRaises = "UnknownRaises",
     hintMsgOrigin = "MsgOrigin", # since 1.3.5
     hintDeclaredLoc = "DeclaredLoc", # since 1.5.1
+    hintUnknownHint = "UnknownHint"
 
 const
   MsgKindToStr*: array[TMsgKind, string] = [
@@ -203,11 +200,8 @@ const
     warnImplicitDefaultValue: "$1",
     warnIgnoredSymbolInjection: "$1",
     warnStdPrefix: "$1 needs the 'std' prefix",
-    warnUnknownNotes: "$1",
-    warnLongLiterals: "$1",
     warnUser: "$1",
     warnGlobalVarConstructorTemporary: "global variable '$1' initialization requires a temporary variable",
-    warnImplicitRangeConversion: "implicit range conversion $1",
     hintSuccess: "operation successful: $#",
     # keep in sync with `testament.isSuccess`
     hintSuccessX: "$build\n$loc lines; ${sec}s; $mem; proj: $project; out: $output",
@@ -241,9 +235,9 @@ const
     hintUser: "$1",
     hintUserRaw: "$1",
     hintExtendedContext: "$1",
-    hintUnknownRaises: "$1 is a forward declaration without explicit .raises, assuming it can raise anything",
     hintMsgOrigin: "$1",
-    hintDeclaredLoc: "$1"
+    hintDeclaredLoc: "$1",
+    hintUnknownHint: "unknown hint: $1"
   ]
 
 const
@@ -262,7 +256,7 @@ type
 
 proc computeNotesVerbosity(): array[0..3, TNoteKinds] =
   result = default(array[0..3, TNoteKinds])
-  result[3] = {low(TNoteKind)..high(TNoteKind)} - {warnObservableStores, warnResultUsed, warnAnyEnumConv, warnBareExcept, warnStdPrefix, warnImplicitRangeConversion}
+  result[3] = {low(TNoteKind)..high(TNoteKind)} - {warnObservableStores, warnResultUsed, warnAnyEnumConv, warnBareExcept, warnStdPrefix}
   result[2] = result[3] - {hintStackTrace, hintExtendedContext, hintDeclaredLoc, hintProcessingStmt}
   result[1] = result[2] - {warnProveField, warnProveIndex,
     warnGcUnsafe, hintPath, hintDependency, hintCodeBegin, hintCodeEnd,

compiler/linter.nim

@@ -95,7 +95,7 @@ proc nep1CheckDefImpl(conf: ConfigRef; info: TLineInfo; s: PSym; k: TSymKind) =
 template styleCheckDef*(ctx: PContext; info: TLineInfo; sym: PSym; k: TSymKind) =
   ## Check symbol definitions adhere to NEP1 style rules.
   if optStyleCheck in ctx.config.options and # ignore if styleChecks are off
-     {optStyleHint, optStyleError, optStyleWarning} * ctx.config.globalOptions != {} and # check only if hint/error/warning is enabled
+     {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
      optStyleUsages notin ctx.config.globalOptions and # ignore if requested to only check name usage
@@ -136,7 +136,7 @@ proc styleCheckUseImpl(conf: ConfigRef; info: TLineInfo; s: PSym) =
 
 template styleCheckUse*(ctx: PContext; info: TLineInfo; sym: PSym) =
   ## Check symbol uses match their definition's style.
-  if {optStyleHint, optStyleError, optStyleWarning} * ctx.config.globalOptions != {} and # ignore if styleChecks are off
+  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
      sym.kind != skTemp and # ignore temporary variables created by the compiler
@@ -152,7 +152,7 @@ proc checkPragmaUseImpl(conf: ConfigRef; info: TLineInfo; w: TSpecialWord; pragm
 template checkPragmaUse*(ctx: PContext; info: TLineInfo; w: TSpecialWord; pragmaName: string, sym: PSym) =
   ## Check builtin pragma uses match their definition's style.
   ## Note: This only applies to builtin pragmas, not user pragmas.
-  if {optStyleHint, optStyleError, optStyleWarning} * ctx.config.globalOptions != {} and # ignore if styleChecks are off
+  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
     checkPragmaUseImpl(ctx.config, info, w, pragmaName)

compiler/llstream.nim

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

compiler/lookups.nim

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

compiler/magicsys.nim

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

compiler/modulegraphs.nim

@@ -11,7 +11,7 @@
 ## represents a complete Nim project. Single modules can either be kept in RAM
 ## or stored in a rod-file.
 
-import std/[intsets, tables, hashes, strtabs, os, strutils, parseutils]
+import std/[intsets, tables, hashes, strtabs, algorithm, os, strutils, parseutils]
 import ../dist/checksums/src/checksums/md5
 import ast, astalgo, options, lineinfos,idents, btrees, ropes, msgs, pathutils, packages, suggestsymdb
 import ic / [packed_ast, ic]
@@ -136,8 +136,6 @@ type
 
     cachedFiles*: StringTableRef
 
-    procGlobals*: seq[PNode]
-
   TPassContext* = object of RootObj # the pass's context
     idgen*: IdGenerator
   PPassContext* = ref TPassContext
@@ -456,10 +454,10 @@ template getPContext(): untyped =
   else: c.c
 
 when defined(nimsuggest):
-  template onUse*(info: TLineInfo; s: PSym; isGenericInstance = false) = discard
+  template onUse*(info: TLineInfo; s: PSym) = discard
   template onDefResolveForward*(info: TLineInfo; s: PSym) = discard
 else:
-  template onUse*(info: TLineInfo; s: PSym; isGenericInstance = false) = discard
+  template onUse*(info: TLineInfo; s: PSym) = discard
   template onDef*(info: TLineInfo; s: PSym) = discard
   template onDefResolveForward*(info: TLineInfo; s: PSym) = discard
 

compiler/modulepaths.nim

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

compiler/msgs.nim

@@ -648,9 +648,7 @@ template internalAssert*(conf: ConfigRef, e: bool) =
 
 template lintReport*(conf: ConfigRef; info: TLineInfo, beau, got: string, extraMsg = "") =
   let m = "'$1' should be: '$2'$3" % [got, beau, extraMsg]
-  let msg = if optStyleError in conf.globalOptions: errGenerated
-            elif optStyleWarning in conf.globalOptions: warnUser
-            else: hintName
+  let msg = if optStyleError in conf.globalOptions: errGenerated else: hintName
   liMessage(conf, info, msg, m, doNothing, instLoc())
 
 proc quotedFilename*(conf: ConfigRef; fi: FileIndex): Rope =

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

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

compiler/nimconf.nim

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

compiler/optimizer.nim

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

compiler/options.nim

@@ -25,7 +25,7 @@ const
   useEffectSystem* = true
   useWriteTracking* = false
   hasFFI* = defined(nimHasLibFFI)
-  copyrightYear* = "2026"
+  copyrightYear* = "2024"
 
   nimEnableCovariance* = defined(nimEnableCovariance)
 
@@ -68,7 +68,6 @@ type                          # please make sure we have under 32 options
     optUseNimcache,           # save artifacts (including binary) in $nimcache
     optStyleHint,             # check that the names adhere to NEP-1
     optStyleError,            # enforce that the names adhere to NEP-1
-    optStyleWarning,          # emit style checks as warnings
     optStyleUsages,           # only enforce consistent **usages** of the symbol
     optSkipSystemConfigFile,  # skip the system's cfg/nims config file
     optSkipProjConfigFile,    # skip the project's cfg/nims config file
@@ -111,8 +110,6 @@ type                          # please make sure we have under 32 options
     optEnableDeepCopy         # ORC specific: enable 'deepcopy' for all types.
     optShowNonExportedFields  # for documentation: show fields that are not exported
     optJsBigInt64             # use bigints for 64-bit integers in JS
-    optDocRaw                 # for documentation: Don't render markdown for JSON output
-    optItaniumMangle          # mangling follows the Itanium spec
 
   TGlobalOptions* = set[TGlobalOption]
 
@@ -232,7 +229,6 @@ type
     # alternative to above:
     genericsOpenSym
     vtables
-    typeBoundOps
 
   LegacyFeature* = enum
     allowSemcheckedAstModification,
@@ -251,8 +247,6 @@ type
       ## Useful for libraries that rely on local passC
     jsNoLambdaLifting
       ## Old transformation for closures in JS backend
-    noPanicOnExcept
-      ## don't panic on bare except
 
   SymbolFilesOption* = enum
     disabledSf, writeOnlySf, readOnlySf, v2Sf, stressTest
@@ -388,7 +382,6 @@ type
     warnCounter*: int
     errorMax*: int
     maxLoopIterationsVM*: int ## VM: max iterations of all loops
-    maxCallDepthVM*: int ## VM: max call depth
     isVmTrace*: bool
     configVars*: StringTableRef
     symbols*: StringTableRef ## We need to use a StringTableRef here as defined
@@ -407,7 +400,6 @@ type
     projectPath*: AbsoluteDir # holds a path like /home/alice/projects/nim/compiler/
     projectFull*: AbsoluteFile # projectPath/projectName
     projectIsStdin*: bool # whether we're compiling from stdin
-    stdinFile*: AbsoluteFile # Filename to use in messages for stdin
     lastMsgWasDot*: set[StdOrrKind] # the last compiler message was a single '.'
     projectMainIdx*: FileIndex # the canonical path id of the main module
     projectMainIdx2*: FileIndex # consider merging with projectMainIdx
@@ -584,7 +576,6 @@ proc newConfigRef*(): ConfigRef =
     projectPath: AbsoluteDir"", # holds a path like /home/alice/projects/nim/compiler/
     projectFull: AbsoluteFile"", # projectPath/projectName
     projectIsStdin: false, # whether we're compiling from stdin
-    stdinFile: AbsoluteFile"stdinfile",
     projectMainIdx: FileIndex(0'i32), # the canonical path id of the main module
     command: "", # the main command (e.g. cc, check, scan, etc)
     commandArgs: @[], # any arguments after the main command
@@ -606,7 +597,6 @@ proc newConfigRef*(): ConfigRef =
     arguments: "",
     suggestMaxResults: 10_000,
     maxLoopIterationsVM: 10_000_000,
-    maxCallDepthVM: 2_000,
     vmProfileData: newProfileData(),
     spellSuggestMax: spellSuggestSecretSauce,
     currentConfigDir: ""
@@ -1041,9 +1031,6 @@ proc isDynlibOverride*(conf: ConfigRef; lib: string): bool =
 proc showNonExportedFields*(conf: ConfigRef) =
   incl(conf.globalOptions, optShowNonExportedFields)
 
-proc docRawOutput*(conf: ConfigRef) =
-  incl(conf.globalOptions, optDocRaw)
-
 proc expandDone*(conf: ConfigRef): bool =
   result = conf.ideCmd == ideExpand and conf.expandLevels == 0 and conf.expandProgress
 

compiler/parampatterns.nim

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

compiler/parser.nim

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

compiler/passes.nim

@@ -42,7 +42,10 @@ proc makePass*(open: TPassOpen = nil,
                process: TPassProcess = nil,
                close: TPassClose = nil,
                isFrontend = false): TPass =
-  result = (open, process, close, isFrontend)
+  result.open = open
+  result.close = close
+  result.process = process
+  result.isFrontend = isFrontend
 
 const
   maxPasses = 10
@@ -97,8 +100,8 @@ proc processModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator;
                     stream: PLLStream): bool {.discardable.} =
   if graph.stopCompile(): return true
   var
-    p: Parser = default(Parser)
-    a: TPassContextArray = default(TPassContextArray)
+    p: Parser
+    a: TPassContextArray
     s: PLLStream
     fileIdx = module.fileIdx
   prepareConfigNotes(graph, module)

compiler/patterns.nim

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

compiler/pipelines.nim

@@ -234,8 +234,7 @@ proc compilePipelineModule*(graph: ModuleGraph; fileIdx: FileIndex; flags: TSymF
     result = moduleFromRodFile(graph, fileIdx, cachedModules)
     let path = toFullPath(graph.config, fileIdx)
     let filename = AbsoluteFile path
-    # it could be a stdinfile/cmdfile
-    if fileExists(filename) and not graph.config.projectIsStdin:
+    if fileExists(filename): # it could be a stdinfile
       graph.cachedFiles[path] = $secureHashFile(path)
     if result == nil:
       result = newModule(graph, fileIdx)

compiler/platform.nim

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

compiler/pragmas.nim

@@ -107,7 +107,7 @@ proc getPragmaVal*(procAst: PNode; name: TSpecialWord): PNode =
       return it[1]
 
 proc pragma*(c: PContext, sym: PSym, n: PNode, validPragmas: TSpecialWords;
-            isStatement: bool = false; comesFromPush = false)
+            isStatement: bool = false)
 
 proc recordPragma(c: PContext; n: PNode; args: varargs[string]) =
   var recorded = newNodeI(nkReplayAction, n.info)
@@ -590,7 +590,7 @@ proc processCompile(c: PContext, n: PNode) =
     var customArgs = ""
     if n.kind in nkCallKinds:
       s = getStrLit(c, n, 1)
-      if n.len == 3:
+      if n.len <= 3:
         customArgs = getStrLit(c, n, 2)
       else:
         localError(c.config, n.info, "'.compile' pragma takes up 2 arguments")
@@ -637,10 +637,7 @@ proc semAsmOrEmit*(con: PContext, n: PNode, marker: char): PNode =
         # XXX what to do here if 'amb' is true?
         if e != nil:
           incl(e.flags, sfUsed)
-          if isDefined(con.config, "nimPreviewAsmSemSymbol"):
-            result.add con.semExprWithType(con, newSymNode(e), {efTypeAllowed})
-          else:
-            result.add newSymNode(e)
+          result.add newSymNode(e)
         else:
           result.add newStrNode(nkStrLit, sub)
       else:
@@ -893,7 +890,7 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
     if keyDeep:
       localError(c.config, it.info, "user pragma cannot have arguments")
 
-    pragma(c, sym, userPragma.ast, validPragmas, isStatement, comesFromPush)
+    pragma(c, sym, userPragma.ast, validPragmas, isStatement)
     n.sons[i..i] = userPragma.ast.sons # expand user pragma with its content
     i.inc(userPragma.ast.len - 1) # inc by -1 is ok, user pragmas was empty
   else:
@@ -947,19 +944,15 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
       of wSize:
         if sym.typ == nil: invalidPragma(c, it)
         var size = expectIntLit(c, it)
-        if sfImportc in sym.flags:
-          # no restrictions on size for imported types
-          setImportedTypeSize(c.config, sym.typ, size)
+        case size
+        of 1, 2, 4:
+          sym.typ.size = size
+          sym.typ.align = int16 size
+        of 8:
+          sym.typ.size = 8
+          sym.typ.align = floatInt64Align(c.config)
         else:
-          case size
-          of 1, 2, 4:
-            sym.typ.size = size
-            sym.typ.align = int16 size
-          of 8:
-            sym.typ.size = 8
-            sym.typ.align = floatInt64Align(c.config)
-          else:
-            localError(c.config, it.info, "size may only be 1, 2, 4 or 8")
+          localError(c.config, it.info, "size may only be 1, 2, 4 or 8")
       of wAlign:
         let alignment = expectIntLit(c, it)
         if isPowerOfTwo(alignment) and alignment > 0:
@@ -1322,12 +1315,8 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
         pragmaProposition(c, it)
       of wEnsures:
         pragmaEnsures(c, it)
-      of wEnforceNoRaises:
+      of wEnforceNoRaises, wQuirky:
         sym.flags.incl sfNeverRaises
-      of wQuirky:
-        sym.flags.incl sfNeverRaises
-        if sym.kind in {skProc, skMethod, skConverter, skFunc, skIterator}:
-          sym.options.incl optQuirky
       of wSystemRaisesDefect:
         sym.flags.incl sfSystemRaisesDefect
       of wVirtual:
@@ -1409,12 +1398,11 @@ proc pragmaRec(c: PContext, sym: PSym, n: PNode, validPragmas: TSpecialWords;
     inc i
 
 proc pragma(c: PContext, sym: PSym, n: PNode, validPragmas: TSpecialWords;
-            isStatement: bool; comesFromPush = false) =
+            isStatement: bool) =
   if n == nil: return
   pragmaRec(c, sym, n, validPragmas, isStatement)
   # XXX: in the case of a callable def, this should use its info
-  if not comesFromPush:
-    implicitPragmas(c, sym, n.info, validPragmas)
+  implicitPragmas(c, sym, n.info, validPragmas)
 
 proc pragmaCallable*(c: PContext, sym: PSym, n: PNode, validPragmas: TSpecialWords,
                     isStatement: bool = false) =

compiler/renderer.nim

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

compiler/reorder.nim

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

compiler/sem.nim

@@ -321,7 +321,7 @@ proc hasCycle(n: PNode): bool =
       break
   excl n.flags, nfNone
 
-proc fixupTypeAfterEval(c: PContext, evaluated, eOrig: PNode; producedClosure: var bool): PNode =
+proc fixupTypeAfterEval(c: PContext, evaluated, eOrig: PNode): PNode =
   # recompute the types as 'eval' isn't guaranteed to construct types nor
   # that the types are sound:
   when true:
@@ -333,7 +333,7 @@ proc fixupTypeAfterEval(c: PContext, evaluated, eOrig: PNode; producedClosure: v
       if hasCycle(result):
         result = localErrorNode(c, eOrig, "the resulting AST is cyclic and cannot be processed further")
       else:
-        semmacrosanity.annotateType(result, expectedType, c.config, producedClosure)
+        semmacrosanity.annotateType(result, expectedType, c.config)
   else:
     result = semExprWithType(c, evaluated)
     #result = fitNode(c, e.typ, result) inlined with special case:
@@ -346,19 +346,6 @@ proc fixupTypeAfterEval(c: PContext, evaluated, eOrig: PNode; producedClosure: v
          isArrayConstr(arg):
         arg.typ = eOrig.typ
 
-proc resetEvalPosition(n: PNode) =
-  # resets the eval position of variables because `tryConstExpr` may be
-  # called multiple times on the same node
-  case n.kind
-  of {nkNone..nkNilLit}-{nkSym}:
-    discard
-  of nkSym:
-    if n.sym.kind in {skVar, skLet} and sfGlobal notin n.sym.flags:
-      n.sym.position = 0
-  else:
-    for i in 0..<n.safeLen:
-      resetEvalPosition(n[i])
-
 proc tryConstExpr(c: PContext, n: PNode; expectedType: PType = nil): PNode =
   var e = semExprWithType(c, n, expectedType = expectedType)
   if e == nil: return
@@ -383,10 +370,7 @@ proc tryConstExpr(c: PContext, n: PNode; expectedType: PType = nil): PNode =
     if result == nil or result.kind == nkEmpty:
       result = nil
     else:
-      var producedClosure = false
-      result = fixupTypeAfterEval(c, result, e, producedClosure)
-      if producedClosure:
-        result = nil
+      result = fixupTypeAfterEval(c, result, e)
 
   except ERecoverableError:
     result = nil
@@ -395,8 +379,6 @@ proc tryConstExpr(c: PContext, n: PNode; expectedType: PType = nil): PNode =
     # Restore the error hook
     c.graph.config.structuredErrorHook = tempHook
 
-  resetEvalPosition(n)
-
   c.config.errorCounter = oldErrorCount
   c.config.errorMax = oldErrorMax
   c.config.m.errorOutputs = oldErrorOutputs
@@ -425,10 +407,7 @@ proc semConstExpr(c: PContext, n: PNode; expectedType: PType = nil): PNode =
       # error correction:
       result = e
     else:
-      var producedClosure = false
-      result = fixupTypeAfterEval(c, result, e, producedClosure)
-      if producedClosure:
-        result = nil
+      result = fixupTypeAfterEval(c, result, e)
 
 proc semExprFlagDispatched(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType = nil): PNode =
   if efNeedStatic in flags:
@@ -521,21 +500,6 @@ proc semAfterMacroCall(c: PContext, call, macroResult: PNode,
   dec(c.config.evalTemplateCounter)
   discard c.friendModules.pop()
 
-proc getLineInfo(n: PNode): TLineInfo =
-  case n.kind
-  of nkPostfix:
-    if len(n) > 1:
-      result = getLineInfo(n[1])
-    else:
-      result = n.info
-  of nkAccQuoted, nkPragmaExpr:
-    if len(n) > 0:
-      result = getLineInfo(n[0])
-    else:
-      result = n.info
-  else:
-    result = n.info
-
 const
   errMissingGenericParamsForTemplate = "'$1' has unspecified generic parameters"
 
@@ -562,9 +526,7 @@ proc semMacroExpr(c: PContext, n, nOrig: PNode, sym: PSym,
   if efNoSemCheck notin flags:
     result = semAfterMacroCall(c, n, result, sym, flags, expectedType)
   if c.config.macrosToExpand.hasKey(sym.name.s):
-    message(c.config, nOrig.info, hintExpandMacro, renderTree(result, {
-      renderNonExportedFields, renderDocComments, renderNoComments
-    }))
+    message(c.config, nOrig.info, hintExpandMacro, renderTree(result))
   result = wrapInComesFrom(nOrig.info, sym, result)
   popInfoContext(c.config)
 
@@ -709,9 +671,8 @@ proc defaultNodeField(c: PContext, a: PNode, aTyp: PType, checkDefault: bool): P
     if child != nil:
       let node = newNode(nkIntLit)
       node.intVal = toInt64(lengthOrd(c.graph.config, aTypSkip))
-      let typeNode = newNode(nkType)
-      typeNode.typ() = makeTypeDesc(c, aTypSkip[1])
-      result = semExpr(c, newTree(nkCall, newTree(nkBracketExpr, newSymNode(getSysSym(c.graph, a.info, "arrayWithDefault"), a.info), typeNode),
+      result = semExpr(c, newTree(nkCall, newSymNode(getSysSym(c.graph, a.info, "arrayWith"), a.info),
+              semExprWithType(c, child),
               node
                 ))
       result.typ() = aTyp
@@ -772,11 +733,9 @@ proc preparePContext*(graph: ModuleGraph; module: PSym; idgen: IdGenerator): PCo
   result.semInferredLambda = semInferredLambda
   result.semGenerateInstance = generateInstance
   result.instantiateOnlyProcType = instantiateOnlyProcType
-  result.fitDefaultNode = fitDefaultNode
   result.semTypeNode = semTypeNode
   result.instTypeBoundOp = sigmatch.instTypeBoundOp
   result.hasUnresolvedArgs = hasUnresolvedArgs
-  result.semAsgnOpr = semAsgnOpr
   result.templInstCounter = new int
 
   pushProcCon(result, module)
@@ -894,9 +853,9 @@ proc semWithPContext*(c: PContext, n: PNode): PNode =
 
 proc reportUnusedModules(c: PContext) =
   if c.config.cmd == cmdM: return
-  for (s, info) in c.unusedImports:
-    if sfUsed notin s.flags:
-      message(c.config, info, warnUnusedImportX, s.name.s)
+  for i in 0..high(c.unusedImports):
+    if sfUsed notin c.unusedImports[i][0].flags:
+      message(c.config, c.unusedImports[i][1], warnUnusedImportX, c.unusedImports[i][0].name.s)
 
 proc closePContext*(graph: ModuleGraph; c: PContext, n: PNode): PNode =
   if c.config.cmd == cmdIdeTools and not c.suggestionsMade:

compiler/semcall.nim

@@ -56,7 +56,7 @@ proc initCandidateSymbols(c: PContext, headSymbol: PNode,
           proc name[T: static proc()]() = T()
           name[proc() = echo"hello"]()
       ]#
-      for paramSym in searchScopesAll(c, symx.name, {skConst}):
+      for paramSym in searchInScopesAllCandidatesFilterBy(c, symx.name, {skConst}):
         let paramTyp = paramSym.typ
         if paramTyp.n.kind == nkSym and paramTyp.n.sym.kind in filter:
           result.add((paramTyp.n.sym, o.lastOverloadScope))
@@ -69,39 +69,6 @@ proc initCandidateSymbols(c: PContext, headSymbol: PNode,
                   result[0].scope, diagnostics)
     best.state = csNoMatch
 
-proc isAttachableRoutineTo(prc: PSym, arg: PType): bool =
-  result = false
-  if arg.owner != prc.owner: return false
-  for i in 1 ..< prc.typ.len:
-    if prc.typ.n[i].kind == nkSym and prc.typ.n[i].sym.ast != nil:
-      # has default value, parameter is not considered in type attachment
-      continue
-    let t = nominalRoot(prc.typ[i])
-    if t != nil and t.itemId == arg.itemId:
-      # parameter `i` is a nominal type in this module
-      # attachable if the nominal root `t` has the same id as `arg`
-      return true
-
-proc addTypeBoundSymbols(graph: ModuleGraph, arg: PType, name: PIdent,
-                         filter: TSymKinds, marker: var IntSet,
-                         syms: var seq[tuple[s: PSym, scope: int]]) =
-  # add type bound ops for `name` based on the argument type `arg`
-  if arg != nil:
-    # argument must be typed first, meaning arguments always
-    # matching `untyped` are ignored
-    let t = nominalRoot(arg)
-    if t != nil and t.owner.kind == skModule:
-      # search module for routines attachable to `t`
-      let module = t.owner
-      var iter = default(ModuleIter)
-      var s = initModuleIter(iter, graph, module, name)
-      while s != nil:
-        if s.kind in filter and s.isAttachableRoutineTo(t) and
-            not containsOrIncl(marker, s.id):
-          # least priority scope, less than explicit imports:
-          syms.add((s, -2))
-        s = nextModuleIter(iter, graph)
-
 proc pickBestCandidate(c: PContext, headSymbol: PNode,
                        n, orig: PNode,
                        initialBinding: PNode,
@@ -121,29 +88,17 @@ proc pickBestCandidate(c: PContext, headSymbol: PNode,
                                   best, alt, o, diagnosticsFlag)
   if len(syms) == 0:
     return
-  let allowTypeBoundOps = typeBoundOps in c.features and
-    # qualified or bound symbols cannot refer to type bound ops
-    headSymbol.kind in {nkIdent, nkAccQuoted, nkOpenSymChoice, nkOpenSym}
-  var symMarker = initIntSet()
-  for s in syms:
-    symMarker.incl(s.s.id)
   # current overload being considered
   var sym = syms[0].s
-  let name = sym.name
   var scope = syms[0].scope
 
-  if allowTypeBoundOps:
-    for a in 1 ..< n.len:
-      # for every already typed argument, add type bound ops
-      let arg = n[a]
-      addTypeBoundSymbols(c.graph, arg.typ, name, filter, symMarker, syms)
-
   # starts at 1 because 0 is already done with setup, only needs checking
   var nextSymIndex = 1
   var z: TCandidate # current candidate
   while true:
     determineType(c, sym)
     z = initCandidate(c, sym, initialBinding, scope, diagnosticsFlag)
+
     # this is kinda backwards as without a check here the described
     # problems in recalc would not happen, but instead it 100%
     # does check forever in some cases
@@ -151,14 +106,6 @@ proc pickBestCandidate(c: PContext, headSymbol: PNode,
       # may introduce new symbols with caveats described in recalc branch
       matches(c, n, orig, z)
 
-      if allowTypeBoundOps:
-        # this match may have given some arguments new types,
-        # in which case add their type bound ops as well
-        # type bound ops of arguments always matching `untyped` are not considered
-        for x in z.newlyTypedOperands:
-          let arg = n[x]
-          addTypeBoundSymbols(c.graph, arg.typ, name, filter, symMarker, syms)
-
       if z.state == csMatch:
         # little hack so that iterators are preferred over everything else:
         if sym.kind == skIterator:
@@ -183,20 +130,13 @@ proc pickBestCandidate(c: PContext, headSymbol: PNode,
       # 1) new symbols are discovered but the loop ends before we recalc
       # 2) new symbols are discovered and resemmed forever
       # not 100% sure if these are possible though as they would rely
-      # on somehow introducing a new overload during overload resolution
+      #  on somehow introducing a new overload during overload resolution
 
       # Symbol table has been modified. Restart and pre-calculate all syms
       # before any further candidate init and compare. SLOW, but rare case.
       syms = initCandidateSymbols(c, headSymbol, initialBinding, filter,
                                   best, alt, o, diagnosticsFlag)
-      symMarker = initIntSet()
-      for s in syms:
-        symMarker.incl(s.s.id)
-      if allowTypeBoundOps:
-        for a in 1 ..< n.len:
-          # for every already typed argument, add type bound ops
-          let arg = n[a]
-          addTypeBoundSymbols(c.graph, arg.typ, name, filter, symMarker, syms)
+
       # reset counter because syms may be in a new order
       symCount = c.currentScope.symbols.counter
       nextSymIndex = 0
@@ -244,6 +184,14 @@ proc effectProblem(f, a: PType; result: var string; c: PContext) =
         if not c.graph.compatibleProps(c.graph, f, a):
           result.add "\n  The `.requires` or `.ensures` properties are incompatible."
 
+proc renderNotLValue(n: PNode): string =
+  result = $n
+  let n = if n.kind == nkHiddenDeref: n[0] else: n
+  if n.kind == nkHiddenCallConv and n.len > 1:
+    result = $n[0] & "(" & result & ")"
+  elif n.kind in {nkHiddenStdConv, nkHiddenSubConv} and n.len == 2:
+    result = typeToString(n.typ.skipTypes(abstractVar)) & "(" & result & ")"
+
 proc presentFailedCandidates(c: PContext, n: PNode, errors: CandidateErrors):
                             (TPreferedDesc, string) =
   var prefer = preferName
@@ -581,7 +529,7 @@ proc resolveOverloads(c: PContext, n, orig: PNode,
   let overloadsState = result.state
   if overloadsState != csMatch:
     if nfDotField in n.flags:
-      internalAssert c.config, f.kind in nkIdentKinds and n.len >= 2
+      internalAssert c.config, f.kind == nkIdent and n.len >= 2
 
       # leave the op head symbol empty,
       # we are going to try multiple variants
@@ -686,14 +634,7 @@ proc instGenericConvertersArg*(c: PContext, a: PNode, x: TCandidate) =
   if a.kind == nkHiddenCallConv and a[0].kind == nkSym:
     let s = a[0].sym
     if s.isGenericRoutineStrict:
-      var src = s.typ.firstParamType
-      var convMatch = newCandidate(c, src)
-      var arg = a[1]
-      if arg.kind in {nkHiddenAddr, nkHiddenSubConv}: arg = arg[^1]
-      let srca = typeRel(convMatch, src, arg.typ)
-      if srca notin {isEqual, isGeneric, isSubtype}:
-        internalError(c.config, a.info, "generic converter failed rematch")
-      let finalCallee = generateInstance(c, s, convMatch.bindings, a.info)
+      let finalCallee = generateInstance(c, s, x.bindings, a.info)
       a[0].sym = finalCallee
       a[0].typ() = finalCallee.typ
       #a.typ = finalCallee.typ.returnType
@@ -830,33 +771,15 @@ proc inheritBindings(c: PContext, x: var TCandidate, expectedType: PType) =
   for i in 0 ..< flatUnbound.len():
     x.bindings.put(flatUnbound[i], flatBound[i])
 
-proc compactVoidArgs(n: PNode): PNode =
-  # deletes void args from the argument list, which are created by `setSon`
-  var hasNil = false
-  for i in 0..<n.len:
-    if n[i] == nil:
-      hasNil = true
-      break
-  if not hasNil:
-    result = n
-  else:
-    result = copyNode(n)
-    for i in 0..<n.len:
-      if n[i] != nil:
-        result.add n[i]
-
 proc semResolvedCall(c: PContext, x: var TCandidate,
                      n: PNode, flags: TExprFlags;
                      expectedType: PType = nil): PNode =
   assert x.state == csMatch
   var finalCallee = x.calleeSym
   let info = getCallLineInfo(n)
-  markUsed(c, info, finalCallee, isGenericInstance = false)
-  onUse(info, finalCallee, isGenericInstance = false)
+  markUsed(c, info, finalCallee)
+  onUse(info, finalCallee)
   assert finalCallee.ast != nil
-  if x.matchedErrorType:
-    markUsed(c, info, finalCallee, isGenericInstance = true)
-    onUse(info, finalCallee, isGenericInstance = true)
   if x.matchedErrorType:
     result = x.call
     result[0] = newSymNode(finalCallee, getCallLineInfo(result[0]))
@@ -892,10 +815,8 @@ proc semResolvedCall(c: PContext, x: var TCandidate,
           x.call.add tn
         else:
           internalAssert c.config, false
-  markUsed(c, info, finalCallee, isGenericInstance = true)
-  onUse(info, finalCallee, isGenericInstance = true)
 
-  result = compactVoidArgs(x.call)
+  result = x.call
   instGenericConvertersSons(c, result, x)
   markConvertersUsed(c, result)
   result[0] = newSymNode(finalCallee, getCallLineInfo(result[0]))
@@ -929,15 +850,15 @@ proc semOverloadedCall(c: PContext, n, nOrig: PNode,
     if c.inGenericContext > 0 and c.matchedConcept == nil:
       result = semGenericStmt(c, n)
       result.typ() = makeTypeFromExpr(c, result.copyTree)
-    elif efNoUndeclared in flags:
-      result = nil
     elif efExplain notin flags:
       # repeat the overload resolution,
       # this time enabling all the diagnostic output (this should fail again)
       result = semOverloadedCall(c, n, nOrig, filter, flags + {efExplain})
-    else:
+    elif efNoUndeclared notin flags:
       result = nil
       notFoundError(c, n, errors)
+    else:
+      result = nil
 
 proc explicitGenericInstError(c: PContext; n: PNode): PNode =
   localError(c.config, getCallLineInfo(n), errCannotInstantiateX % renderTree(n))
@@ -962,10 +883,8 @@ proc explicitGenericSym(c: PContext, n: PNode, s: PSym, errors: var CandidateErr
   var newInst = generateInstance(c, s, m.bindings, n.info)
   newInst.typ.flags.excl tfUnresolved
   let info = getCallLineInfo(n)
-  markUsed(c, info, s, isGenericInstance = false)
-  onUse(info, s, isGenericInstance = false)
-  markUsed(c, info, newInst, isGenericInstance = true)
-  onUse(info, newInst, isGenericInstance = true)
+  markUsed(c, info, s)
+  onUse(info, s)
   result = newSymNode(newInst, info)
 
 proc setGenericParams(c: PContext, n, expectedParams: PNode) =
@@ -993,14 +912,8 @@ proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym, doError: bool)
     # common case; check the only candidate has the right
     # number of generic type parameters:
     result = explicitGenericSym(c, n, s, errors, doError)
-    if result == nil:
-      if c.inGenericContext > 0:
-        # same as in semOverloadedCall, make expression untyped,
-        # may have failed match due to unresolved types
-        result = semGenericStmt(c, n)
-        result.typ() = makeTypeFromExpr(c, result.copyTree)
-      elif doError:
-        notFoundError(c, n, errors)
+    if doError and result == nil:
+      notFoundError(c, n, errors)
   elif a.kind in {nkClosedSymChoice, nkOpenSymChoice}:
     # choose the generic proc with the proper number of type parameters.
     result = newNodeI(a.kind, getCallLineInfo(n))
@@ -1010,14 +923,6 @@ proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym, doError: bool)
                             skFunc, skIterator}:
         let x = explicitGenericSym(c, n, candidate, errors, doError)
         if x != nil: result.add(x)
-        elif c.inGenericContext > 0:
-          # same as in semOverloadedCall, make expression untyped,
-          # may have failed match due to unresolved types
-          # any failing match stops building the symchoice for correctness,
-          # can also make it untyped from the start
-          result = semGenericStmt(c, n)
-          result.typ() = makeTypeFromExpr(c, result.copyTree)
-          return
     # get rid of nkClosedSymChoice if not ambiguous:
     if result.len == 0:
       result = nil

compiler/semdata.nim

@@ -9,15 +9,14 @@
 
 ## This module contains the data structures for the semantic checking phase.
 
-import std/[tables, intsets, sets, strutils]
+import std/[tables, intsets, sets]
 
 when defined(nimPreviewSlimSystem):
   import std/assertions
 
 import
   options, ast, msgs, idents, renderer,
-  magicsys, vmdef, modulegraphs, lineinfos, pathutils, layeredtable,
-  types, lowerings, trees, parampatterns, astalgo
+  magicsys, vmdef, modulegraphs, lineinfos, pathutils, layeredtable
 
 import ic / ic
 
@@ -42,7 +41,7 @@ type
     breakInLoop*: bool        # whether we are in a loop without block
     next*: PProcCon           # used for stacking procedure contexts
     mappingExists*: bool
-    mapping*: SymMapping
+    mapping*: Table[ItemId, PSym]
     caseContext*: seq[tuple[n: PNode, idx: int]]
     localBindStmts*: seq[PNode]
 
@@ -143,7 +142,6 @@ type
     instantiateOnlyProcType*: proc (c: PContext, pt: LayeredIdTable,
                                     prc: PSym, info: TLineInfo): PType
       # used by sigmatch for explicit generic instantiations
-    fitDefaultNode*: proc (c: PContext, n: var PNode, expectedType: PType)
     includedFiles*: IntSet    # used to detect recursive include files
     pureEnumFields*: TStrTable   # pure enum fields that can be used unambiguously
     userPragmas*: TStrTable
@@ -153,6 +151,7 @@ type
     generics*: seq[TInstantiationPair] # pending list of instantiated generics to compile
     topStmts*: int # counts the number of encountered top level statements
     lastGenericIdx*: int      # used for the generics stack
+    hloLoopDetector*: int     # used to prevent endless loops in the HLO
     inParallelStmt*: int
     instTypeBoundOp*: proc (c: PContext; dc: PSym; t: PType; info: TLineInfo;
                             op: TTypeAttachedOp; col: int): PSym {.nimcall.}
@@ -173,9 +172,6 @@ type
     importModuleLookup*: Table[int, seq[int]] # (module.ident.id, [module.id])
     skipTypes*: seq[PNode] # used to skip types between passes in type section. So far only used for inheritance, sets and generic bodies.
     inTypeofContext*: int
-
-    semAsgnOpr*: proc (c: PContext; n: PNode; k: TNodeKind): PNode {.nimcall.}
-
   TBorrowState* = enum
     bsNone, bsReturnNotMatch, bsNoDistinct, bsGeneric, bsNotSupported, bsMatch
 
@@ -257,7 +253,7 @@ proc popProcCon*(c: PContext) {.inline.} = c.p = c.p.next
 
 proc put*(p: PProcCon; key, val: PSym) =
   if not p.mappingExists:
-    p.mapping = initSymMapping()
+    p.mapping = initTable[ItemId, PSym]()
     p.mappingExists = true
   #echo "put into table ", key.info
   p.mapping[key.itemId] = val
@@ -289,24 +285,22 @@ proc considerGenSyms*(c: PContext; n: PNode) =
       considerGenSyms(c, n[i])
 
 proc newOptionEntry*(conf: ConfigRef): POptionEntry =
-  result = POptionEntry(
-    options: conf.options,
-    defaultCC: ccNimCall,
-    dynlib: nil,
-    notes: conf.notes,
-    warningAsErrors: conf.warningAsErrors
-  )
+  new(result)
+  result.options = conf.options
+  result.defaultCC = ccNimCall
+  result.dynlib = nil
+  result.notes = conf.notes
+  result.warningAsErrors = conf.warningAsErrors
 
 proc pushOptionEntry*(c: PContext): POptionEntry =
-  let prev = c.optionStack[^1]
-  result = POptionEntry(
-    options: c.config.options,
-    defaultCC: prev.defaultCC,
-    dynlib: prev.dynlib,
-    notes: c.config.notes,
-    warningAsErrors: c.config.warningAsErrors,
-    features: c.features
-  )
+  new(result)
+  var prev = c.optionStack[^1]
+  result.options = c.config.options
+  result.defaultCC = prev.defaultCC
+  result.dynlib = prev.dynlib
+  result.notes = c.config.notes
+  result.warningAsErrors = c.config.warningAsErrors
+  result.features = c.features
   c.optionStack.add(result)
 
 proc popOptionEntry*(c: PContext) =
@@ -317,23 +311,22 @@ proc popOptionEntry*(c: PContext) =
   c.optionStack.setLen(c.optionStack.len - 1)
 
 proc newContext*(graph: ModuleGraph; module: PSym): PContext =
-  result = PContext(
-    optionStack: @[newOptionEntry(graph.config)],
-    libs: @[],
-    module: module,
-    friendModules: @[module],
-    converters: @[],
-    patterns: @[],
-    includedFiles: initIntSet(),
-    pureEnumFields: initStrTable(),
-    userPragmas: initStrTable(),
-    generics: @[],
-    unknownIdents: initIntSet(),
-    cache: graph.cache,
-    graph: graph,
-    signatures: initStrTable(),
-    features: graph.config.features
-  )
+  new(result)
+  result.optionStack = @[newOptionEntry(graph.config)]
+  result.libs = @[]
+  result.module = module
+  result.friendModules = @[module]
+  result.converters = @[]
+  result.patterns = @[]
+  result.includedFiles = initIntSet()
+  result.pureEnumFields = initStrTable()
+  result.userPragmas = initStrTable()
+  result.generics = @[]
+  result.unknownIdents = initIntSet()
+  result.cache = graph.cache
+  result.graph = graph
+  result.signatures = initStrTable()
+  result.features = graph.config.features
   if graph.config.symbolFiles != disabledSf:
     let id = module.position
     if graph.config.cmd != cmdM:
@@ -397,7 +390,8 @@ proc reexportSym*(c: PContext; s: PSym) =
     addReexport(c.encoder, c.packedRepr, s)
 
 proc newLib*(kind: TLibKind): PLib =
-  result = PLib(kind: kind)   #result.syms = initObjectSet()
+  new(result)
+  result.kind = kind          #result.syms = initObjectSet()
 
 proc addToLib*(lib: PLib, sym: PSym) =
   #if sym.annex != nil and not isGenericRoutine(sym):
@@ -640,166 +634,3 @@ proc rememberExpansion*(c: PContext; info: TLineInfo; expandedSym: PSym) =
   ## delegated to the "rod" file mechanism.
   if c.config.symbolFiles != disabledSf:
     storeExpansion(c.encoder, c.packedRepr, info, expandedSym)
-
-const
-  errVarForOutParamNeededX = "for a 'var' type a variable needs to be passed; but '$1' is immutable"
-  errXStackEscape = "address of '$1' may not escape its stack frame"
-
-proc renderNotLValue*(n: PNode): string =
-  result = $n
-  let n = if n.kind == nkHiddenDeref: n[0] else: n
-  if n.kind == nkHiddenCallConv and n.len > 1:
-    result = $n[0] & "(" & result & ")"
-  elif n.kind in {nkHiddenStdConv, nkHiddenSubConv} and n.len == 2:
-    result = typeToString(n.typ.skipTypes(abstractVar)) & "(" & result & ")"
-
-proc isAssignable(c: PContext, n: PNode): TAssignableResult =
-  result = parampatterns.isAssignable(c.p.owner, n)
-
-proc newHiddenAddrTaken(c: PContext, n: PNode, isOutParam: bool): PNode =
-  if n.kind == nkHiddenDeref and not (c.config.backend == backendCpp or
-                                      sfCompileToCpp in c.module.flags):
-    checkSonsLen(n, 1, c.config)
-    result = n[0]
-  else:
-    result = newNodeIT(nkHiddenAddr, n.info, makeVarType(c, n.typ))
-    result.add n
-    let aa = isAssignable(c, n)
-    let sym = getRoot(n)
-    if aa notin {arLValue, arLocalLValue}:
-      if aa == arDiscriminant and c.inUncheckedAssignSection > 0:
-        discard "allow access within a cast(unsafeAssign) section"
-      elif strictDefs in c.features and aa == arAddressableConst and
-              sym != nil and sym.kind == skLet and isOutParam:
-        discard "allow let varaibles to be passed to out parameters"
-      else:
-        localError(c.config, n.info, errVarForOutParamNeededX % renderNotLValue(n))
-
-proc analyseIfAddressTaken(c: PContext, n: PNode, isOutParam: bool): PNode =
-  result = n
-  case n.kind
-  of nkSym:
-    # n.sym.typ can be nil in 'check' mode ...
-    if n.sym.typ != nil and
-        skipTypes(n.sym.typ, abstractInst-{tyTypeDesc}).kind notin {tyVar, tyLent}:
-      incl(n.sym.flags, sfAddrTaken)
-      result = newHiddenAddrTaken(c, n, isOutParam)
-  of nkDotExpr:
-    checkSonsLen(n, 2, c.config)
-    if n[1].kind != nkSym:
-      internalError(c.config, n.info, "analyseIfAddressTaken")
-      return
-    if skipTypes(n[1].sym.typ, abstractInst-{tyTypeDesc}).kind notin {tyVar, tyLent}:
-      incl(n[1].sym.flags, sfAddrTaken)
-      result = newHiddenAddrTaken(c, n, isOutParam)
-  of nkBracketExpr:
-    checkMinSonsLen(n, 1, c.config)
-    if skipTypes(n[0].typ, abstractInst-{tyTypeDesc}).kind notin {tyVar, tyLent}:
-      if n[0].kind == nkSym: incl(n[0].sym.flags, sfAddrTaken)
-      result = newHiddenAddrTaken(c, n, isOutParam)
-  else:
-    result = newHiddenAddrTaken(c, n, isOutParam)
-
-proc analyseIfAddressTakenInCall*(c: PContext, n: PNode, isConverter = false) =
-  checkMinSonsLen(n, 1, c.config)
-  if n[0].typ == nil:
-    # n[0] might be erroring node in nimsuggest
-    return
-  const
-    FakeVarParams = {mNew, mNewFinalize, mInc, ast.mDec, mIncl, mExcl,
-      mSetLengthStr, mSetLengthSeq, mSetLengthSeqUninit, mAppendStrCh, mAppendStrStr, mSwap,
-      mAppendSeqElem, mNewSeq, mShallowCopy, mDeepCopy, mMove, mWasMoved}
-
-  template checkIfConverterCalled(c: PContext, n: PNode) =
-    ## Checks if there is a converter call which wouldn't be checked otherwise
-    # Call can sometimes be wrapped in a deref
-    let node = if n.kind == nkHiddenDeref: n[0] else: n
-    if node.kind == nkHiddenCallConv:
-      analyseIfAddressTakenInCall(c, node, true)
-  # get the real type of the callee
-  # it may be a proc var with a generic alias type, so we skip over them
-  var t = n[0].typ.skipTypes({tyGenericInst, tyAlias, tySink})
-  if n[0].kind == nkSym and n[0].sym.magic in FakeVarParams:
-    # BUGFIX: check for L-Value still needs to be done for the arguments!
-    # note sometimes this is eval'ed twice so we check for nkHiddenAddr here:
-    for i in 1..<n.len:
-      if i < t.len and t[i] != nil and
-          skipTypes(t[i], abstractInst-{tyTypeDesc}).kind in {tyVar}:
-        let it = n[i]
-        let aa = isAssignable(c, it)
-        if aa notin {arLValue, arLocalLValue}:
-          if it.kind != nkHiddenAddr:
-            if aa == arDiscriminant and c.inUncheckedAssignSection > 0:
-              discard "allow access within a cast(unsafeAssign) section"
-            else:
-              localError(c.config, it.info, errVarForOutParamNeededX % $it)
-        # Make sure to still check arguments for converters
-        c.checkIfConverterCalled(n[i])
-    # bug #5113: disallow newSeq(result) where result is a 'var T':
-    if n[0].sym.magic in {mNew, mNewFinalize, mNewSeq}:
-      var arg = n[1] #.skipAddr
-      if arg.kind == nkHiddenDeref: arg = arg[0]
-      if arg.kind == nkSym and arg.sym.kind == skResult and
-          arg.typ.skipTypes(abstractInst).kind in {tyVar, tyLent}:
-        localError(c.config, n.info, errXStackEscape % renderTree(n[1], {renderNoComments}))
-
-    return
-  for i in 1..<n.len:
-    let n = if n.kind == nkHiddenDeref: n[0] else: n
-    c.checkIfConverterCalled(n[i])
-    if i < t.len and
-        skipTypes(t[i], abstractInst-{tyTypeDesc}).kind in {tyVar}:
-      # Converters wrap var parameters in nkHiddenAddr but they haven't been analysed yet.
-      # So we need to make sure we are checking them still when in a converter call
-      if n[i].kind != nkHiddenAddr or isConverter:
-        n[i] = analyseIfAddressTaken(c, n[i].skipAddr(), isOutParam(skipTypes(t[i], abstractInst-{tyTypeDesc})))
-
-
-proc replaceHookMagic*(c: PContext, n: PNode, kind: TTypeAttachedOp): PNode =
-  ## Replaces builtin generic hooks with lifted hooks.
-  case kind
-  of attachedDestructor:
-    result = n
-    let t = n[1].typ.skipTypes(abstractVar)
-    let op = getAttachedOp(c.graph, t, attachedDestructor)
-    if op != nil:
-      result[0] = newSymNode(op)
-      if op.typ != nil and op.typ.len == 2 and op.typ.firstParamType.kind != tyVar:
-        if n[1].kind == nkSym and n[1].sym.kind == skParam and
-            n[1].typ.kind == tyVar:
-          result[1] = genDeref(n[1])
-        else:
-          result[1] = skipAddr(n[1])
-  of attachedTrace:
-    result = n
-    let t = n[1].typ.skipTypes(abstractVar)
-    let op = getAttachedOp(c.graph, t, attachedTrace)
-    if op != nil:
-      result[0] = newSymNode(op)
-  of attachedDup:
-    result = n
-    let t = n[1].typ.skipTypes(abstractVar)
-    let op = getAttachedOp(c.graph, t, attachedDup)
-    if op != nil:
-      result[0] = newSymNode(op)
-      if op.typ.len == 3:
-        let boolLit = newIntLit(c.graph, n.info, 1)
-        boolLit.typ() = getSysType(c.graph, n.info, tyBool)
-        result.add boolLit
-  of attachedWasMoved:
-    result = n
-    let t = n[1].typ.skipTypes(abstractVar)
-    let op = getAttachedOp(c.graph, t, attachedWasMoved)
-    if op != nil:
-      result[0] = newSymNode(op)
-      analyseIfAddressTakenInCall(c, result, false)
-  of attachedSink:
-    result = c.semAsgnOpr(c, n, nkSinkAsgn)
-  of attachedAsgn:
-    result = c.semAsgnOpr(c, n, nkAsgn)
-  of attachedDeepCopy:
-    result = n
-    let t = n[1].typ.skipTypes(abstractVar)
-    let op = getAttachedOp(c.graph, t, kind)
-    if op != nil:
-      result[0] = newSymNode(op)

compiler/semexprs.nim

@@ -16,6 +16,7 @@ when defined(nimCompilerStacktraceHints):
 const
   errExprXHasNoType = "expression '$1' has no type (or is ambiguous)"
   errXExpectsTypeOrValue = "'$1' expects a type or value"
+  errVarForOutParamNeededX = "for a 'var' type a variable needs to be passed; but '$1' is immutable"
   errXStackEscape = "address of '$1' may not escape its stack frame"
   errExprHasNoAddress = "expression has no address"
   errCannotInterpretNodeX = "cannot evaluate '$1'"
@@ -113,8 +114,6 @@ proc semExprNoDeref(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
 
 proc semSymGenericInstantiation(c: PContext, n: PNode, s: PSym): PNode =
   result = symChoice(c, n, s, scClosed)
-  if result.kind == nkSym:
-    markUsed(c, n.info, s)
 
 proc semSym(c: PContext, n: PNode, sym: PSym, flags: TExprFlags): PNode
 
@@ -726,7 +725,7 @@ proc semArrayConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PTyp
   # 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 or n.typ.kind == tyFromExpr
+  let constructType = n.typ.isNil
   var expectedElementType, expectedIndexType: PType = nil
   var expectedBase: PType = nil
   if constructType:
@@ -775,11 +774,7 @@ proc semArrayConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PTyp
 
     let yy = semExprWithType(c, x, {efTypeAllowed}, expectedElementType)
     var typ: PType
-    var isGeneric = false
-    if yy.typ != nil and yy.typ.kind == tyFromExpr:
-      isGeneric = true
-      typ = nil # will not be used
-    elif constructType:
+    if constructType:
       typ = yy.typ
       if expectedElementType == nil:
         expectedElementType = typ
@@ -804,21 +799,11 @@ proc semArrayConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PTyp
 
       let xx = semExprWithType(c, x, {efTypeAllowed}, expectedElementType)
       result.add xx
-      if xx.typ != nil and xx.typ.kind == tyFromExpr:
-        isGeneric = true
-      elif constructType:
+      if constructType:
         typ = commonType(c, typ, xx.typ)
       #n[i] = semExprWithType(c, x, {})
       #result.add fitNode(c, typ, n[i])
       inc(lastIndex)
-    if isGeneric:
-      for i in 0..<result.len:
-        if result[i].typ != nil and isIntLit(result[i].typ):
-          # generic instantiation strips int lit type which makes conversions fail
-          result[i].typ() = nil
-      result.typ() = nil # current result.typ is invalid, index type is nil
-      result.typ() = makeTypeFromExpr(c, result.copyTree)
-      return
     if constructType:
       addSonSkipIntLit(result.typ, typ, c.idgen)
     for i in 0..<result.len:
@@ -832,6 +817,9 @@ proc semArrayConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PTyp
 proc fixAbstractType(c: PContext, n: PNode) =
   for i in 1..<n.len:
     let it = n[i]
+    if it == nil:
+      localError(c.config, n.info, "'$1' has nil child at index $2" % [renderTree(n, {renderNoComments}), $i])
+      return
     # do not get rid of nkHiddenSubConv for OpenArrays, the codegen needs it:
     if it.kind == nkHiddenSubConv and
         skipTypes(it.typ, abstractVar).kind notin {tyOpenArray, tyVarargs}:
@@ -877,6 +865,105 @@ proc hasUnresolvedArgs(c: PContext, n: PNode): bool =
       if hasUnresolvedArgs(c, n[i]): return true
     return false
 
+proc newHiddenAddrTaken(c: PContext, n: PNode, isOutParam: bool): PNode =
+  if n.kind == nkHiddenDeref and not (c.config.backend == backendCpp or
+                                      sfCompileToCpp in c.module.flags):
+    checkSonsLen(n, 1, c.config)
+    result = n[0]
+  else:
+    result = newNodeIT(nkHiddenAddr, n.info, makeVarType(c, n.typ))
+    result.add n
+    let aa = isAssignable(c, n)
+    let sym = getRoot(n)
+    if aa notin {arLValue, arLocalLValue}:
+      if aa == arDiscriminant and c.inUncheckedAssignSection > 0:
+        discard "allow access within a cast(unsafeAssign) section"
+      elif strictDefs in c.features and aa == arAddressableConst and
+              sym != nil and sym.kind == skLet and isOutParam:
+        discard "allow let varaibles to be passed to out parameters"
+      else:
+        localError(c.config, n.info, errVarForOutParamNeededX % renderNotLValue(n))
+
+proc analyseIfAddressTaken(c: PContext, n: PNode, isOutParam: bool): PNode =
+  result = n
+  case n.kind
+  of nkSym:
+    # n.sym.typ can be nil in 'check' mode ...
+    if n.sym.typ != nil and
+        skipTypes(n.sym.typ, abstractInst-{tyTypeDesc}).kind notin {tyVar, tyLent}:
+      incl(n.sym.flags, sfAddrTaken)
+      result = newHiddenAddrTaken(c, n, isOutParam)
+  of nkDotExpr:
+    checkSonsLen(n, 2, c.config)
+    if n[1].kind != nkSym:
+      internalError(c.config, n.info, "analyseIfAddressTaken")
+      return
+    if skipTypes(n[1].sym.typ, abstractInst-{tyTypeDesc}).kind notin {tyVar, tyLent}:
+      incl(n[1].sym.flags, sfAddrTaken)
+      result = newHiddenAddrTaken(c, n, isOutParam)
+  of nkBracketExpr:
+    checkMinSonsLen(n, 1, c.config)
+    if skipTypes(n[0].typ, abstractInst-{tyTypeDesc}).kind notin {tyVar, tyLent}:
+      if n[0].kind == nkSym: incl(n[0].sym.flags, sfAddrTaken)
+      result = newHiddenAddrTaken(c, n, isOutParam)
+  else:
+    result = newHiddenAddrTaken(c, n, isOutParam)
+
+proc analyseIfAddressTakenInCall(c: PContext, n: PNode, isConverter = false) =
+  checkMinSonsLen(n, 1, c.config)
+  if n[0].typ == nil:
+    # n[0] might be erroring node in nimsuggest
+    return
+  const
+    FakeVarParams = {mNew, mNewFinalize, mInc, ast.mDec, mIncl, mExcl,
+      mSetLengthStr, mSetLengthSeq, mAppendStrCh, mAppendStrStr, mSwap,
+      mAppendSeqElem, mNewSeq, mShallowCopy, mDeepCopy, mMove,
+      mWasMoved}
+
+  template checkIfConverterCalled(c: PContext, n: PNode) =
+    ## Checks if there is a converter call which wouldn't be checked otherwise
+    # Call can sometimes be wrapped in a deref
+    let node = if n.kind == nkHiddenDeref: n[0] else: n
+    if node.kind == nkHiddenCallConv:
+      analyseIfAddressTakenInCall(c, node, true)
+  # get the real type of the callee
+  # it may be a proc var with a generic alias type, so we skip over them
+  var t = n[0].typ.skipTypes({tyGenericInst, tyAlias, tySink})
+  if n[0].kind == nkSym and n[0].sym.magic in FakeVarParams:
+    # BUGFIX: check for L-Value still needs to be done for the arguments!
+    # note sometimes this is eval'ed twice so we check for nkHiddenAddr here:
+    for i in 1..<n.len:
+      if i < t.len and t[i] != nil and
+          skipTypes(t[i], abstractInst-{tyTypeDesc}).kind in {tyVar}:
+        let it = n[i]
+        let aa = isAssignable(c, it)
+        if aa notin {arLValue, arLocalLValue}:
+          if it.kind != nkHiddenAddr:
+            if aa == arDiscriminant and c.inUncheckedAssignSection > 0:
+              discard "allow access within a cast(unsafeAssign) section"
+            else:
+              localError(c.config, it.info, errVarForOutParamNeededX % $it)
+        # Make sure to still check arguments for converters
+        c.checkIfConverterCalled(n[i])
+    # bug #5113: disallow newSeq(result) where result is a 'var T':
+    if n[0].sym.magic in {mNew, mNewFinalize, mNewSeq}:
+      var arg = n[1] #.skipAddr
+      if arg.kind == nkHiddenDeref: arg = arg[0]
+      if arg.kind == nkSym and arg.sym.kind == skResult and
+          arg.typ.skipTypes(abstractInst).kind in {tyVar, tyLent}:
+        localError(c.config, n.info, errXStackEscape % renderTree(n[1], {renderNoComments}))
+
+    return
+  for i in 1..<n.len:
+    let n = if n.kind == nkHiddenDeref: n[0] else: n
+    c.checkIfConverterCalled(n[i])
+    if i < t.len and
+        skipTypes(t[i], abstractInst-{tyTypeDesc}).kind in {tyVar}:
+      # Converters wrap var parameters in nkHiddenAddr but they haven't been analysed yet.
+      # So we need to make sure we are checking them still when in a converter call
+      if n[i].kind != nkHiddenAddr or isConverter:
+        n[i] = analyseIfAddressTaken(c, n[i].skipAddr(), isOutParam(skipTypes(t[i], abstractInst-{tyTypeDesc})))
+
 include semmagic
 
 proc evalAtCompileTime(c: PContext, n: PNode): PNode =
@@ -919,9 +1006,9 @@ proc evalAtCompileTime(c: PContext, n: PNode): PNode =
       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
@@ -948,15 +1035,11 @@ proc evalAtCompileTime(c: PContext, n: PNode): PNode =
         result = evalStaticExpr(c.module, c.idgen, c.graph, call, c.p.owner)
         if result.isNil:
           localError(c.config, n.info, errCannotInterpretNodeX % renderTree(call))
-        else:
-          var producedClosure = false
-          result = fixupTypeAfterEval(c, result, n, producedClosure)
+        else: result = fixupTypeAfterEval(c, result, n)
       else:
         result = evalConstExpr(c.module, c.idgen, c.graph, call)
         if result.isNil: result = n
-        else:
-          var producedClosure = false
-          result = fixupTypeAfterEval(c, result, n, producedClosure)
+        else: result = fixupTypeAfterEval(c, result, n)
     else:
       result = n
     #if result != n:
@@ -974,8 +1057,7 @@ proc semStaticExpr(c: PContext, n: PNode; expectedType: PType = nil): PNode =
     localError(c.config, n.info, errCannotInterpretNodeX % renderTree(n))
     result = c.graph.emptyNode
   else:
-    var producedClosure = false
-    result = fixupTypeAfterEval(c, result, a, producedClosure)
+    result = fixupTypeAfterEval(c, result, a)
 
 proc semOverloadedCallAnalyseEffects(c: PContext, n: PNode, nOrig: PNode,
                                      flags: TExprFlags; expectedType: PType = nil): PNode =
@@ -1152,7 +1234,7 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType
           localError(c.config, n.info, msg)
         return errorNode(c, n)
     else:
-      result = compactVoidArgs(m.call)
+      result = m.call
       instGenericConvertersSons(c, result, m)
       markConvertersUsed(c, result)
 
@@ -1294,9 +1376,7 @@ proc readTypeParameter(c: PContext, typ: PType,
             # This seems semantically correct and then we'll be able
             # to return the section symbol directly here
             let foundType = makeTypeDesc(c, def[2].typ)
-            let s = copySym(def[0].sym, c.idgen)
-            s.typ = foundType
-            return newSymNode(s, info)
+            return newSymNode(copySym(def[0].sym, c.idgen).linkTo(foundType), info)
 
       of nkConstSection:
         for def in statement:
@@ -1321,9 +1401,7 @@ proc readTypeParameter(c: PContext, typ: PType,
             return c.graph.emptyNode
         else:
           let foundTyp = makeTypeDesc(c, rawTyp)
-          let s = copySym(tParam.sym, c.idgen)
-          s.typ = foundTyp
-          return newSymNode(s, info)
+          return newSymNode(copySym(tParam.sym, c.idgen).linkTo(foundTyp), info)
 
   return nil
 
@@ -1414,8 +1492,6 @@ proc semSym(c: PContext, n: PNode, sym: PSym, flags: TExprFlags): PNode =
     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)
@@ -1602,46 +1678,29 @@ proc builtinFieldAccess(c: PContext; n: PNode; flags: var TExprFlags): PNode =
     result = tryReadingGenericParam(c, n, i, t)
     flags.incl efCannotBeDotCall
 
-proc hiddenDerefDepth(n: PNode): int =
-  result = 0
-  var n = n
-  while n.kind == nkHiddenDeref:
-    inc result
-    n = n[0]
-
-proc dotTransformation(c: PContext, n: PNode, initialDerefs: int): PNode =
-  var root = n[0]
-  let currentDerefs = hiddenDerefDepth(root)
-  if currentDerefs > initialDerefs:
-    # hidden derefs were inserted by `builtinFieldAccess` for fields of
-    # `ref object` etc.
-    # undo the derefs for overload resolution
-    for _ in initialDerefs ..< currentDerefs:
-      root = root[0]
-  root = copyTree(root)
+proc dotTransformation(c: PContext, n: PNode): PNode =
   if isSymChoice(n[1]) or
       # generics usually leave field names as symchoices, but not types
       (n[1].kind == nkSym and n[1].sym.kind == skType):
     result = newNodeI(nkDotCall, n.info)
     result.add n[1]
-    result.add root
+    result.add copyTree(n[0])
   else:
     var i = considerQuotedIdent(c, n[1], n)
     result = newNodeI(nkDotCall, n.info)
     result.flags.incl nfDotField
     result.add newIdentNode(i, n[1].info)
-    result.add root
+    result.add copyTree(n[0])
 
 proc semFieldAccess(c: PContext, n: PNode, flags: TExprFlags): PNode =
   # this is difficult, because the '.' is used in many different contexts
   # in Nim. We first allow types in the semantic checking.
   var f = flags - {efIsDotCall}
-  let initialDerefDepth = hiddenDerefDepth(n[0])
   result = builtinFieldAccess(c, n, f)
   if result == nil or ((result.typ == nil or result.typ.skipTypes(abstractInst).kind != tyProc) and
       efIsDotCall in flags and callOperator notin c.features and
       efCannotBeDotCall notin f):
-    result = dotTransformation(c, n, initialDerefDepth)
+    result = dotTransformation(c, n)
 
 proc buildOverloadedSubscripts(n: PNode, ident: PIdent): PNode =
   result = newNodeI(nkCall, n.info)
@@ -1658,9 +1717,6 @@ proc semDeref(c: PContext, n: PNode, flags: TExprFlags): PNode =
     n[0] = a
   result = n
   var t = skipTypes(n[0].typ, {tyGenericInst, tyVar, tyLent, tyAlias, tySink, tyOwned})
-  if t.kind == tyTypeDesc:
-    localError(c.config, n.info, "missing generic parameter")
-    return nil
   case t.kind
   of tyRef, tyPtr: n.typ() = t.elementType
   of tyMetaTypes, tyFromExpr:
@@ -1758,9 +1814,7 @@ proc semSubscript(c: PContext, n: PNode, flags: TExprFlags, afterOverloading = f
         # type parameters: partial generic specialization
         n[0] = semSymGenericInstantiation(c, n[0], s)
         result = maybeInstantiateGeneric(c, n, s, doError = afterOverloading)
-        if result != nil and
-            # leave untyped generic expression alone:
-            (result.typ == nil or result.typ.kind != tyFromExpr):
+        if result != nil:
           # check newly created sym/symchoice
           result = semExpr(c, result, flags)
       of skMacro, skTemplate:
@@ -1798,7 +1852,7 @@ proc propertyWriteAccess(c: PContext, n, nOrig, a: PNode): PNode =
   result = newTreeI(nkCall, n.info, setterId, a[0], n[1])
   result.flags.incl nfDotSetter
   let orig = newTreeI(nkCall, n.info, setterId, aOrig[0], nOrig[1])
-  result = semOverloadedCallAnalyseEffects(c, result, orig, {efNoUndeclared})
+  result = semOverloadedCallAnalyseEffects(c, result, orig, {})
 
   if result != nil:
     result = afterCallActions(c, result, nOrig, {})
@@ -1932,20 +1986,8 @@ proc makeTupleAssignments(c: PContext; n: PNode): PNode =
 
   for i in 0..<lhs.len:
     if lhs[i].kind == nkIdent and lhs[i].ident.id == ord(wUnderscore):
-      # tuple unpacking `skTemp` does not generate a destructor and
-      # expects all fields to be unpacked, so instead of skipping,
-      # generate `let _ = temp[i]` which should generate a destructor
-      let utemp = newSym(skLet, lhs[i].ident, c.idgen, getCurrOwner(c), lhs[i].info)
-      utemp.typ = value.typ[i]
-      temp.flags.incl(sfGenSym)
-      var uv = newNodeI(nkLetSection, lhs[i].info)
-      let utempNode = newSymNode(utemp)
-      var uvpart = newNodeI(nkIdentDefs, v.info, 3)
-      uvpart[0] = utempNode
-      uvpart[1] = c.graph.emptyNode
-      uvpart[2] = newTupleAccessRaw(tempNode, i)
-      uv.add uvpart
-      result.add(uv)
+      # skip _ assignments if we are using a temp as they are already evaluated
+      discard
     else:
       result.add newAsgnStmt(lhs[i], newTupleAccessRaw(tempNode, i))
 
@@ -1958,48 +2000,34 @@ proc semAsgn(c: PContext, n: PNode; mode=asgnNormal): PNode =
     # --> `f=` (r, x)
     let nOrig = n.copyTree
     var flags = {efLValue}
-    let initialDerefDepth = hiddenDerefDepth(a[0])
     a = builtinFieldAccess(c, a, flags)
     if a == nil:
       a = propertyWriteAccess(c, n, nOrig, n[0])
       if a != nil: return a
       # we try without the '='; proc that return 'var' or macros are still
       # possible:
-      a = dotTransformation(c, n[0], initialDerefDepth)
+      a = dotTransformation(c, n[0])
       if a.kind == nkDotCall:
         a.transitionSonsKind(nkCall)
         a = semExprWithType(c, a, {efLValue})
   of nkBracketExpr:
     # a[i] = x
     # --> `[]=`(a, i, x)
-    # try builtin subscript for LHS first:
     a = semSubscript(c, a, {efLValue})
     if a == nil:
+      result = buildOverloadedSubscripts(n[0], getIdent(c.cache, "[]="))
+      result.add(n[1])
       if mode == noOverloadedSubscript:
-        # `[]=` overloads failed and builtin subscript failed, try `[]` overloads for LHS
-        # will error if not found:
-        a = semExprWithType(c, n[0], {efLValue})
+        bracketNotFoundError(c, result, {})
+        return errorNode(c, n)
       else:
-        # magic overload of `[]=` will always match so cannot check for mismatch here,
-        # will go to above `if` branch instead
-        result = buildOverloadedSubscripts(n[0], getIdent(c.cache, "[]="))
-        result.add(n[1])
         result = semExprNoType(c, result)
         return result
   of nkCurlyExpr:
     # a{i} = x -->  `{}=`(a, i, x)
-    # no builtin behavior/magic overloads for curly subscript,
-    # try `{}=` overloads first then try `{}` overloads for LHS:
-    let nOrig = n.copyTree
     result = buildOverloadedSubscripts(n[0], getIdent(c.cache, "{}="))
     result.add(n[1])
-    result = semOverloadedCallAnalyseEffects(c, result, result.copyTree, {efNoUndeclared})
-    if result != nil:
-      result = afterCallActions(c, result, nOrig, {})
-      return
-    else:
-      # will error if `{}` overloads not found:
-      a = semExprWithType(c, a, {efLValue})
+    return semExprNoType(c, result)
   of nkPar, nkTupleConstr:
     if a.len >= 2 or a.kind == nkTupleConstr:
       # unfortunately we need to rewrite ``(x, y) = foo()`` already here so
@@ -2217,8 +2245,10 @@ proc lookUpForDeclared(c: PContext, n: PNode, onlyCurrentScope: bool): PSym =
         result = someSym(c.graph, m, ident)
   of nkSym:
     result = n.sym
-  of nkOpenSymChoice, nkClosedSymChoice, nkOpenSym:
+  of nkOpenSymChoice, nkClosedSymChoice:
     result = n[0].sym
+  of nkOpenSym:
+    result = lookUpForDeclared(c, n[0], onlyCurrentScope)
   else:
     localError(c.config, n.info, "identifier expected, but got: " & renderTree(n))
     result = nil
@@ -2756,21 +2786,16 @@ proc semSetConstr(c: PContext, n: PNode, expectedType: PType = nil): PNode =
   else:
     # only semantic checking for all elements, later type checking:
     var typ: PType = nil
-    var isGeneric = false
     for i in 0..<n.len:
       let doSetType = typ == nil
       if isRange(n[i]):
         checkSonsLen(n[i], 3, c.config)
         n[i][1] = semExprWithType(c, n[i][1], {efTypeAllowed}, expectedElementType)
         n[i][2] = semExprWithType(c, n[i][2], {efTypeAllowed}, expectedElementType)
-        if (n[i][1].typ != nil and n[i][1].typ.kind == tyFromExpr) or
-            (n[i][2].typ != nil and n[i][2].typ.kind == tyFromExpr):
-          isGeneric = true
-        else:
-          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
+        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
       elif n[i].kind == nkRange:
         # already semchecked
         if doSetType:
@@ -2778,11 +2803,9 @@ proc semSetConstr(c: PContext, n: PNode, expectedType: PType = nil): PNode =
                           {tyGenericInst, tyVar, tyLent, tyOrdinal, tyAlias, tySink})
       else:
         n[i] = semExprWithType(c, n[i], {efTypeAllowed}, expectedElementType)
-        if n[i].typ != nil and n[i].typ.kind == tyFromExpr:
-          isGeneric = true
-        elif doSetType:
+        if doSetType:
           typ = skipTypes(n[i].typ, {tyGenericInst, tyVar, tyLent, tyOrdinal, tyAlias, tySink})
-      if doSetType and not isGeneric:
+      if doSetType:
         if not isOrdinalType(typ, allowEnumWithHoles=true):
           localError(c.config, n.info, errOrdinalTypeExpected % typeToString(typ, preferDesc))
           typ = makeRangeType(c, 0, MaxSetElements-1, n.info)
@@ -2797,14 +2820,6 @@ proc semSetConstr(c: PContext, n: PNode, expectedType: PType = nil): PNode =
           typ = makeRangeType(c, 0, MaxSetElements-1, n.info)
         if expectedElementType == nil:
           expectedElementType = typ
-    if isGeneric:
-      for i in 0..<n.len:
-        if n[i].typ != nil and isIntLit(n[i].typ):
-          # generic instantiation strips int lit type which makes conversions fail
-          n[i].typ() = nil
-        result.add n[i]
-      result.typ() = makeTypeFromExpr(c, result.copyTree)
-      return
     addSonSkipIntLit(result.typ, typ, c.idgen)
     for i in 0..<n.len:
       var m: PNode
@@ -2877,7 +2892,6 @@ proc semTupleFieldsConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType
   var typ = newTypeS(tyTuple, c)
   typ.n = newNodeI(nkRecList, n.info) # nkIdentDefs
   var ids = initIntSet()
-  var isGeneric = false
   for i in 0..<n.len:
     if n[i].kind != nkExprColonExpr:
       illFormedAst(n[i], c.config)
@@ -2887,17 +2901,12 @@ proc semTupleFieldsConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType
     # can check if field name matches expected type here
     let expectedElemType = if expected != nil: expected[i] else: nil
     n[i][1] = semExprWithType(c, n[i][1], {}, expectedElemType)
-    if n[i][1].typ != nil and n[i][1].typ.kind == tyFromExpr:
-      isGeneric = true
-    elif expectedElemType != nil and
+    if expectedElemType != nil and
         (expectedElemType.kind != tyNil and not hasEmpty(expectedElemType)):
       # hasEmpty/nil check is to not break existing code like
       # `const foo = [(1, {}), (2, {false})]`,
       # `const foo = if true: (0, nil) else: (1, new(int))`
-      let conversion = indexTypesMatch(c, expectedElemType, n[i][1].typ, n[i][1])
-      # ignore matching error, full tuple will be matched later which may call converter, see #24609
-      if conversion != nil:
-        n[i][1] = conversion
+      n[i][1] = fitNode(c, expectedElemType, n[i][1], n[i][1].info)
 
     if n[i][1].typ.kind == tyTypeDesc:
       localError(c.config, n[i][1].info, "typedesc not allowed as tuple field.")
@@ -2910,21 +2919,7 @@ proc semTupleFieldsConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType
     typ.n.add newSymNode(f)
     n[i][0] = newSymNode(f)
     result.add n[i]
-  if isGeneric:
-    for i in 0..<result.len:
-      if result[i][1].typ != nil and isIntLit(result[i][1].typ):
-        # generic instantiation strips int lit type which makes conversions fail
-        result[i][1].typ() = nil
-    result.typ() = makeTypeFromExpr(c, result.copyTree)
-    return
-  let oldType = n.typ
   result.typ() = typ
-  if oldType != nil and not hasEmpty(oldType): # see hasEmpty comment above
-    # convert back to old type
-    let conversion = indexTypesMatch(c, oldType, typ, result)
-    # ignore matching error, the goal is just to keep the original type info
-    if conversion != nil:
-      result.typ() = oldType
 
 proc semTuplePositionsConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType = nil): PNode =
   result = n                  # we don't modify n, but compute the type:
@@ -2935,37 +2930,17 @@ proc semTuplePositionsConstr(c: PContext, n: PNode, flags: TExprFlags; expectedT
     if not (expected.kind == tyTuple and expected.len == n.len):
       expected = nil
   var typ = newTypeS(tyTuple, c)  # leave typ.n nil!
-  var isGeneric = false
   for i in 0..<n.len:
     let expectedElemType = if expected != nil: expected[i] else: nil
     n[i] = semExprWithType(c, n[i], {}, expectedElemType)
-    if n[i].typ != nil and n[i].typ.kind == tyFromExpr:
-      isGeneric = true
-    elif expectedElemType != nil and
+    if expectedElemType != nil and
         (expectedElemType.kind != tyNil and not hasEmpty(expectedElemType)):
       # hasEmpty/nil check is to not break existing code like
       # `const foo = [(1, {}), (2, {false})]`,
       # `const foo = if true: (0, nil) else: (1, new(int))`
-      let conversion = indexTypesMatch(c, expectedElemType, n[i].typ, n[i])
-      # ignore matching error, full tuple will be matched later which may call converter, see #24609
-      if conversion != nil:
-        n[i] = conversion
+      n[i] = fitNode(c, expectedElemType, n[i], n[i].info)
     addSonSkipIntLit(typ, n[i].typ.skipTypes({tySink}), c.idgen)
-  if isGeneric:
-    for i in 0..<result.len:
-      if result[i].typ != nil and isIntLit(result[i].typ):
-        # generic instantiation strips int lit type which makes conversions fail
-        result[i].typ() = nil
-    result.typ() = makeTypeFromExpr(c, result.copyTree)
-    return
-  let oldType = n.typ
   result.typ() = typ
-  if oldType != nil and not hasEmpty(oldType): # see hasEmpty comment above
-    # convert back to old type
-    let conversion = indexTypesMatch(c, oldType, typ, result)
-    # ignore matching error, the goal is just to keep the original type info
-    if conversion != nil:
-      result.typ() = oldType
 
 include semobjconstr
 
@@ -3053,39 +3028,28 @@ proc semExport(c: PContext, n: PNode): PNode =
 
         s = nextOverloadIter(o, c, a)
 
-proc isTypeTupleField(n: PNode): bool {.inline.} =
-  result = n.typ.kind == tyTypeDesc or
-    (n.typ.kind == tyGenericParam and n.typ.sym.kind == skGenericParam)
-    # `skGenericParam` stays as `tyGenericParam` type rather than being wrapped in `tyTypeDesc`
-    # would check if `n` itself is an `skGenericParam` symbol, but these symbols semcheck to an ident
-    # maybe check if `n` is an ident to ensure this is not a value with the generic param type?
-
 proc semTupleConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType = nil): PNode =
-  result = semTuplePositionsConstr(c, n, flags, expectedType)
-  if result.typ.kind == tyFromExpr:
-    # tyFromExpr is already ambivalent between types and values
-    return
-  var tupexp = result
-  while tupexp.kind == nkHiddenSubConv: tupexp = tupexp[1]
+  var tupexp = semTuplePositionsConstr(c, n, flags, expectedType)
   var isTupleType: bool = false
   if tupexp.len > 0: # don't interpret () as type
-    internalAssert c.config, tupexp.kind == nkTupleConstr
-    isTupleType = isTypeTupleField(tupexp[0])
+    isTupleType = tupexp[0].typ.kind == tyTypeDesc
     # check if either everything or nothing is tyTypeDesc
     for i in 1..<tupexp.len:
-      if isTupleType != isTypeTupleField(tupexp[i]):
+      if isTupleType != (tupexp[i].typ.kind == tyTypeDesc):
         return localErrorNode(c, n, tupexp[i].info, "Mixing types and values in tuples is not allowed.")
   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)
+  else:
+    result = tupexp
 
 proc isExplicitGenericCall(c: PContext, n: PNode): bool =
   ## checks if a call node `n` is a routine call with explicit generic params
-  ##
+  ## 
   ## the callee node needs to be either an nkBracketExpr or a call to a
   ## symchoice of `[]` in which case it will be transformed into nkBracketExpr
-  ##
+  ## 
   ## the LHS of the bracket expr has to either be a symchoice or resolve to
   ## a routine symbol
   template checkCallee(n: PNode) =
@@ -3331,7 +3295,6 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType
       #performProcvarCheck(c, n, s)
       result = symChoice(c, n, s, scClosed)
       if result.kind == nkSym:
-        markUsed(c, n.info, s)
         markIndirect(c, result.sym)
         # if isGenericRoutine(result.sym):
         #   localError(c.config, n.info, errInstantiateXExplicitly, s.name.s)
@@ -3581,7 +3544,6 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType
   of nkMacroDef: result = semMacroDef(c, n)
   of nkTemplateDef: result = semTemplateDef(c, n)
   of nkImportStmt:
-    trySuggestModuleNames(c, n)
     # this particular way allows 'import' in a 'compiles' context so that
     # template canImport(x): bool =
     #   compiles:

compiler/semfields.nim

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

compiler/semfold.nim

@@ -16,7 +16,7 @@ import
   commands, magicsys, modulegraphs, lineinfos, wordrecg
 
 import std/[strutils, math, strtabs]
-#from system/memory import nimCStrLen
+from system/memory import nimCStrLen
 
 when defined(nimPreviewSlimSystem):
   import std/[assertions, formatfloat]
@@ -179,30 +179,29 @@ proc evalOp(m: TMagic, n, a, b, c: PNode; idgen: IdGenerator; g: ModuleGraph): P
     let argB = getInt(b)
     result = newIntNodeT(if argA > argB: argA else: argB, n, idgen, g)
   of mShlI:
-    let valueB = toInt64(getInt(b)) and (n.typ.size * 8 - 1)
     case skipTypes(n.typ, abstractRange).kind
-    of tyInt8: result = newIntNodeT(toInt128(toInt8(getInt(a)) shl valueB), n, idgen, g)
-    of tyInt16: result = newIntNodeT(toInt128(toInt16(getInt(a)) shl valueB), n, idgen, g)
-    of tyInt32: result = newIntNodeT(toInt128(toInt32(getInt(a)) shl valueB), n, idgen, g)
-    of tyInt64: result = newIntNodeT(toInt128(toInt64(getInt(a)) shl valueB), n, idgen, g)
+    of tyInt8: result = newIntNodeT(toInt128(toInt8(getInt(a)) shl toInt64(getInt(b))), n, idgen, g)
+    of tyInt16: result = newIntNodeT(toInt128(toInt16(getInt(a)) shl toInt64(getInt(b))), n, idgen, g)
+    of tyInt32: result = newIntNodeT(toInt128(toInt32(getInt(a)) shl toInt64(getInt(b))), n, idgen, g)
+    of tyInt64: result = newIntNodeT(toInt128(toInt64(getInt(a)) shl toInt64(getInt(b))), n, idgen, g)
     of tyInt:
       if g.config.target.intSize == 4:
-        result = newIntNodeT(toInt128(toInt32(getInt(a)) shl valueB), n, idgen, g)
+        result = newIntNodeT(toInt128(toInt32(getInt(a)) shl toInt64(getInt(b))), n, idgen, g)
       else:
-        result = newIntNodeT(toInt128(toInt64(getInt(a)) shl valueB), n, idgen, g)
-    of tyUInt8: result = newIntNodeT(toInt128(toUInt8(getInt(a)) shl valueB), n, idgen, g)
-    of tyUInt16: result = newIntNodeT(toInt128(toUInt16(getInt(a)) shl valueB), n, idgen, g)
-    of tyUInt32: result = newIntNodeT(toInt128(toUInt32(getInt(a)) shl valueB), n, idgen, g)
-    of tyUInt64: result = newIntNodeT(toInt128(toUInt64(getInt(a)) shl valueB), n, idgen, g)
+        result = newIntNodeT(toInt128(toInt64(getInt(a)) shl toInt64(getInt(b))), n, idgen, g)
+    of tyUInt8: result = newIntNodeT(toInt128(toUInt8(getInt(a)) shl toInt64(getInt(b))), n, idgen, g)
+    of tyUInt16: result = newIntNodeT(toInt128(toUInt16(getInt(a)) shl toInt64(getInt(b))), n, idgen, g)
+    of tyUInt32: result = newIntNodeT(toInt128(toUInt32(getInt(a)) shl toInt64(getInt(b))), n, idgen, g)
+    of tyUInt64: result = newIntNodeT(toInt128(toUInt64(getInt(a)) shl toInt64(getInt(b))), n, idgen, g)
     of tyUInt:
       if g.config.target.intSize == 4:
-        result = newIntNodeT(toInt128(toUInt32(getInt(a)) shl valueB), n, idgen, g)
+        result = newIntNodeT(toInt128(toUInt32(getInt(a)) shl toInt64(getInt(b))), n, idgen, g)
       else:
-        result = newIntNodeT(toInt128(toUInt64(getInt(a)) shl valueB), n, idgen, g)
+        result = newIntNodeT(toInt128(toUInt64(getInt(a)) shl toInt64(getInt(b))), n, idgen, g)
     else: internalError(g.config, n.info, "constant folding for shl")
   of mShrI:
     var a = cast[uint64](getInt(a))
-    let b = cast[uint64](getInt(b)) and cast[uint64](n.typ.size * 8 - 1)
+    let b = cast[uint64](getInt(b))
     # To support the ``-d:nimOldShiftRight`` flag, we need to mask the
     # signed integers to cut off the extended sign bit in the internal
     # representation.
@@ -221,13 +220,12 @@ proc evalOp(m: TMagic, n, a, b, c: PNode; idgen: IdGenerator; g: ModuleGraph): P
     let c = cast[BiggestInt](a shr b)
     result = newIntNodeT(toInt128(c), n, idgen, g)
   of mAshrI:
-    let valueB = toInt64(getInt(b)) and (n.typ.size * 8 - 1)
     case skipTypes(n.typ, abstractRange).kind
-    of tyInt8: result =  newIntNodeT(toInt128(ashr(toInt8(getInt(a)), valueB)), n, idgen, g)
-    of tyInt16: result = newIntNodeT(toInt128(ashr(toInt16(getInt(a)), valueB)), n, idgen, g)
-    of tyInt32: result = newIntNodeT(toInt128(ashr(toInt32(getInt(a)), valueB)), n, idgen, g)
+    of tyInt8: result =  newIntNodeT(toInt128(ashr(toInt8(getInt(a)), toInt8(getInt(b)))), n, idgen, g)
+    of tyInt16: result = newIntNodeT(toInt128(ashr(toInt16(getInt(a)), toInt16(getInt(b)))), n, idgen, g)
+    of tyInt32: result = newIntNodeT(toInt128(ashr(toInt32(getInt(a)), toInt32(getInt(b)))), n, idgen, g)
     of tyInt64, tyInt:
-      result = newIntNodeT(toInt128(ashr(toInt64(getInt(a)), valueB)), n, idgen, g)
+      result = newIntNodeT(toInt128(ashr(toInt64(getInt(a)), toInt64(getInt(b)))), n, idgen, g)
     else: internalError(g.config, n.info, "constant folding for ashr")
   of mDivI:
     let argA = getInt(a)
@@ -473,20 +471,19 @@ proc foldArrayAccess(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNo
       if result.kind == nkExprColonExpr: result = result[1]
     else:
       result = nil
-      #localError(g.config, n.info, formatErrorIndexBound(idx, x.len-1) & $n)
+      localError(g.config, n.info, formatErrorIndexBound(idx, x.len-1) & $n)
   of nkBracket:
     idx -= toInt64(firstOrd(g.config, x.typ))
     if idx >= 0 and idx < x.len: result = x[int(idx)]
     else:
       result = nil
-      #localError(g.config, n.info, formatErrorIndexBound(idx, x.len-1) & $n)
+      localError(g.config, n.info, formatErrorIndexBound(idx, x.len-1) & $n)
   of nkStrLit..nkTripleStrLit:
     result = newNodeIT(nkCharLit, x.info, n.typ)
     if idx >= 0 and idx < x.strVal.len:
       result.intVal = ord(x.strVal[int(idx)])
     else:
-      result = nil
-      #localError(g.config, n.info, formatErrorIndexBound(idx, x.strVal.len-1) & $n)
+      localError(g.config, n.info, formatErrorIndexBound(idx, x.strVal.len-1) & $n)
   else: result = nil
 
 proc foldFieldAccess(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode =
@@ -592,7 +589,7 @@ proc foldDefine(m, s: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
             raise newException(ValueError, "invalid enum value: " & str)
         else:
           localError(g.config, s.info, "unsupported type $1 for define '$2'" %
-            [typeToString(rawTyp), name])
+            [name, typeToString(rawTyp)])
       except ValueError as e:
         localError(g.config, s.info,
           "could not process define '$1' of type $2; $3" %

compiler/semgnrc.nim

@@ -218,7 +218,7 @@ proc fuzzyLookup(c: PContext, n: PNode, flags: TSemGenericFlags,
     let ident = considerQuotedIdent(c, n)
     # could be type conversion if like a.T and not a.T()
     let symKinds = if inCall: routineKinds else: routineKinds+{skType}
-    var candidates = selectFromScopesElseAll(c, ident, symKinds)
+    var candidates = searchInScopesFilterBy(c, ident, symKinds)
     if candidates.len > 0:
       let s = candidates[0] # XXX take into account the other candidates!
       isMacro = s.kind in {skTemplate, skMacro}
@@ -274,8 +274,7 @@ proc semGenericStmt(c: PContext, n: PNode,
     result = lookup(c, n, flags, ctx)
     if result != nil and result.kind == nkSym:
       assert result.sym != nil
-      incl result.sym.flags, sfUsed
-      markOwnerModuleAsUsed(c, result.sym)
+      markUsed(c, n.info, result.sym)
   of nkDotExpr:
     #let luf = if withinMixin notin flags: {checkUndeclared} else: {}
     #var s = qualifiedLookUp(c, n, luf)

compiler/seminst.nim

@@ -308,8 +308,6 @@ proc instantiateProcType(c: PContext, pt: LayeredIdTable,
       param.typ = result[i]
 
     result.n[i] = newSymNode(param)
-    if isRecursiveStructuralType(result[i]):
-      localError(c.config, originalParams[i].sym.info, "illegal recursion in type '" & typeToString(result[i]) & "'")
     propagateToOwner(result, result[i])
     addDecl(c, param)
 
@@ -320,8 +318,6 @@ proc instantiateProcType(c: PContext, pt: LayeredIdTable,
   cl.isReturnType = false
   result.n[0] = originalParams[0].copyTree
   if result[0] != nil:
-    if isRecursiveStructuralType(result[0]):
-      localError(c.config, originalParams[0].info, "illegal recursion in type '" & typeToString(result[0]) & "'")
     propagateToOwner(result, result[0])
 
   eraseVoidParams(result)

compiler/semmacrosanity.nim

@@ -10,28 +10,9 @@
 ## Implements type sanity checking for ASTs resulting from macros. Lots of
 ## room for improvement here.
 
-import ast, msgs, types, options, trees, nimsets
+import ast, msgs, types, options
 
-type
-  FieldTracker = object
-    index: int
-    remaining: int
-    constr: PNode
-    delete: bool # to delete fields from inactive case branches
-  FieldInfo = ref object
-    sym: PSym
-    delete: bool
-
-proc caseBranchMatchesExpr(branch, matched: PNode): bool =
-  # copied from sem
-  result = false
-  for i in 0 ..< branch.len-1:
-    if branch[i].kind == nkRange:
-      if overlap(branch[i], matched): return true
-    elif exprStructuralEquivalent(branch[i], matched):
-      return true
-
-proc ithField(n: PNode, field: var FieldTracker): FieldInfo =
+proc ithField(n: PNode, field: var int): PSym =
   result = nil
   case n.kind
   of nkRecList:
@@ -42,42 +23,18 @@ proc ithField(n: PNode, field: var FieldTracker): FieldInfo =
     if n[0].kind != nkSym: return
     result = ithField(n[0], field)
     if result != nil: return
-    # value of the discriminator field, from (index - remaining - 1 + 1):
-    # - 1 because the `ithField` call above decreased it by 1,
-    # + 1 because the constructor node has an initial type child
-    let val = field.constr[field.index - field.remaining][1]
-    var branchFound = false
     for i in 1..<n.len:
-      let previousDelete = field.delete
       case n[i].kind
-      of nkOfBranch:
-        if branchFound or previousDelete or
-            not caseBranchMatchesExpr(n[i], val):
-          # if this is not the active case branch,
-          # mark all fields inside as deleted
-          field.delete = true
-        else:
-          branchFound = true
+      of nkOfBranch, nkElse:
         result = ithField(lastSon(n[i]), field)
         if result != nil: return
-        field.delete = previousDelete
-      of nkElse:
-        if branchFound:
-          # if this is not the active case branch,
-          # mark all fields inside as deleted
-          field.delete = true
-        result = ithField(lastSon(n[i]), field)
-        if result != nil: return
-        field.delete = previousDelete
       else: discard
   of nkSym:
-    if field.remaining == 0:
-      result = FieldInfo(sym: n.sym, delete: field.delete)
-    else:
-      dec(field.remaining)
+    if field == 0: result = n.sym
+    else: dec(field)
   else: discard
 
-proc ithField(t: PType, field: var FieldTracker): FieldInfo =
+proc ithField(t: PType, field: var int): PSym =
   var base = t.baseClass
   while base != nil:
     let b = skipTypes(base, skipPtrs)
@@ -86,7 +43,7 @@ proc ithField(t: PType, field: var FieldTracker): FieldInfo =
     base = b.baseClass
   result = ithField(t.n, field)
 
-proc annotateType*(n: PNode, t: PType; conf: ConfigRef; producedClosure: var bool) =
+proc annotateType*(n: PNode, t: PType; conf: ConfigRef) =
   let x = t.skipTypes(abstractInst+{tyRange})
   # Note: x can be unequal to t and we need to be careful to use 't'
   # to not to skip tyGenericInst
@@ -96,26 +53,21 @@ proc annotateType*(n: PNode, t: PType; conf: ConfigRef; producedClosure: var boo
     n.typ() = t
     n[0].typ() = t
     for i in 1..<n.len:
-      var tracker = FieldTracker(index: i-1, remaining: i-1, constr: n, delete: false)
-      let field = x.ithField(tracker)
+      var j = i-1
+      let field = x.ithField(j)
       if field.isNil:
         globalError conf, n.info, "invalid field at index " & $i
       else:
         internalAssert(conf, n[i].kind == nkExprColonExpr)
-        annotateType(n[i][1], field.sym.typ, conf, producedClosure)
-        if field.delete:
-          # only codegen fields from active case branches
-          incl(n[i].flags, nfPreventCg)
+        annotateType(n[i][1], field.typ, conf)
   of nkPar, nkTupleConstr:
     if x.kind == tyTuple:
       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, producedClosure)
+        else: annotateType(n[i], x[i], conf)
     elif x.kind == tyProc and x.callConv == ccClosure:
       n.typ() = t
-      if n.len > 1 and n[1].kind notin {nkEmpty, nkNilLit}:
-        producedClosure = true
     elif x.kind == tyOpenArray: # `opcSlice` transforms slices into tuples
       if n.kind == nkTupleConstr:
         let
@@ -127,11 +79,11 @@ proc annotateType*(n: PNode, t: PType; conf: ConfigRef; producedClosure: var boo
         of nkStrKinds:
           for i in left..right:
             bracketExpr.add newIntNode(nkCharLit, BiggestInt n[0].strVal[i])
-            annotateType(bracketExpr[^1], x.elementType, conf, producedClosure)
+            annotateType(bracketExpr[^1], x.elementType, conf)
         of nkBracket:
           for i in left..right:
             bracketExpr.add n[0][i]
-            annotateType(bracketExpr[^1], x.elementType, conf, producedClosure)
+            annotateType(bracketExpr[^1], x.elementType, conf)
         else:
           globalError(conf, n.info, "Incorrectly generated tuple constr")
         n[] = bracketExpr[]
@@ -142,18 +94,13 @@ proc annotateType*(n: PNode, t: PType; conf: ConfigRef; producedClosure: var boo
   of nkBracket:
     if x.kind in {tyArray, tySequence, tyOpenArray}:
       n.typ() = t
-      for m in n: annotateType(m, x.elemType, conf, producedClosure)
+      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
-      for m in n:
-        if m.kind == nkRange:
-          annotateType(m[0], x.elemType, conf, producedClosure)
-          annotateType(m[1], x.elemType, conf, producedClosure)
-        else:
-          annotateType(m, x.elemType, conf, producedClosure)
+      for m in n: annotateType(m, x.elemType, conf)
     else:
       globalError(conf, n.info, "{} must have the set type")
   of nkFloatLit..nkFloat128Lit:

compiler/semmagic.nim

@@ -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.skipTypes({tySink}))
+  result.typ() = makePtrType(c, x.typ)
 
 proc semTypeOf(c: PContext; n: PNode): PNode =
   var m = BiggestInt 1 # typeOfIter
@@ -55,15 +55,7 @@ proc semTypeOf(c: PContext; n: PNode): PNode =
   result.add typExpr
   if typExpr.typ.kind == tyFromExpr:
     typExpr.typ.flags.incl tfNonConstExpr
-  var t = typExpr.typ
-  if t.kind == tyStatic:
-    let base = t.skipTypes({tyStatic})
-    if c.inGenericContext > 0 and base.containsGenericType:
-      t = makeTypeFromExpr(c, copyTree(typExpr))
-      t.flags.incl tfNonConstExpr
-    else:
-      t = base
-  result.typ() = makeTypeDesc(c, t)
+  result.typ() = makeTypeDesc(c, typExpr.typ)
 
 type
   SemAsgnMode = enum asgnNormal, noOverloadedSubscript, noOverloadedAsgn
@@ -243,7 +235,7 @@ proc evalTypeTrait(c: PContext; traitCall: PNode, operand: PType, context: PSym)
     let cond = operand.kind == tyTuple and operand.n != nil
     result = newIntNodeT(toInt128(ord(cond)), traitCall, c.idgen, c.graph)
   of "tupleLen":
-    var operand = operand.skipTypes({tyGenericInst, tyAlias})
+    var operand = operand.skipTypes({tyGenericInst})
     assert operand.kind == tyTuple, $operand.kind
     result = newIntNodeT(toInt128(operand.len), traitCall, c.idgen, c.graph)
   of "distinctBase":
@@ -544,33 +536,31 @@ proc semNewFinalize(c: PContext; n: PNode): PNode =
       else:
         if fin.instantiatedFrom != nil and fin.instantiatedFrom != fin.owner: #undo move
           setOwner(fin, 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)
+        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)
+        # 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 =
@@ -612,10 +602,9 @@ proc magicsAfterOverloadResolution(c: PContext, n: PNode,
   of mArrPut:
     result = semArrPut(c, n, flags)
   of mAsgn:
-    case n[0].sym.name.s
-    of "=", "=copy":
+    if n[0].sym.name.s == "=":
       result = semAsgnOpr(c, n, nkAsgn)
-    of "=sink":
+    elif n[0].sym.name.s == "=sink":
       result = semAsgnOpr(c, n, nkSinkAsgn)
     else:
       result = semShallowCopy(c, n, flags)
@@ -654,20 +643,49 @@ proc magicsAfterOverloadResolution(c: PContext, n: PNode,
   of mNewFinalize:
     result = semNewFinalize(c, n)
   of mDestroy:
-    result = replaceHookMagic(c, n, attachedDestructor)
+    result = n
+    let t = n[1].typ.skipTypes(abstractVar)
+    let op = getAttachedOp(c.graph, t, attachedDestructor)
+    if op != nil:
+      result[0] = newSymNode(op)
+      if op.typ != nil and op.typ.len == 2 and op.typ.firstParamType.kind != tyVar:
+        if n[1].kind == nkSym and n[1].sym.kind == skParam and
+            n[1].typ.kind == tyVar:
+          result[1] = genDeref(n[1])
+        else:
+          result[1] = skipAddr(n[1])
   of mTrace:
-    result = replaceHookMagic(c, n, attachedTrace)
+    result = n
+    let t = n[1].typ.skipTypes(abstractVar)
+    let op = getAttachedOp(c.graph, t, attachedTrace)
+    if op != nil:
+      result[0] = newSymNode(op)
   of mDup:
-    result = replaceHookMagic(c, n, attachedDup)
+    result = n
+    let t = n[1].typ.skipTypes(abstractVar)
+    let op = getAttachedOp(c.graph, t, attachedDup)
+    if op != nil:
+      result[0] = newSymNode(op)
+      if op.typ.len == 3:
+        let boolLit = newIntLit(c.graph, n.info, 1)
+        boolLit.typ() = getSysType(c.graph, n.info, tyBool)
+        result.add boolLit
   of mWasMoved:
-    result = replaceHookMagic(c, n, attachedWasMoved)
+    result = n
+    let t = n[1].typ.skipTypes(abstractVar)
+    let op = getAttachedOp(c.graph, t, attachedWasMoved)
+    if op != nil:
+      result[0] = newSymNode(op)
+      let addrExp = newNodeIT(nkHiddenAddr, result[1].info, makePtrType(c, t))
+      addrExp.add result[1]
+      result[1] = addrExp
   of mUnown:
     result = semUnown(c, n)
   of mExists, mForall:
     result = semQuantifier(c, n)
   of mOld:
     result = semOld(c, n)
-  of mSetLengthSeq, mSetLengthSeqUninit:
+  of mSetLengthSeq:
     result = n
     let seqType = result[1].typ.skipTypes({tyPtr, tyRef, # in case we had auto-dereferencing
                                            tyVar, tyGenericInst, tyOwned, tySink,

compiler/semobjconstr.nim

@@ -68,10 +68,6 @@ proc locateFieldInInitExpr(c: PContext, field: PSym, initExpr: PNode): PNode =
     let assignment = initExpr[i]
     if assignment.kind != nkExprColonExpr:
       invalidObjConstr(c, assignment)
-    elif nfPreventCg in assignment.flags:
-      # this is an object constructor node generated by the VM and
-      # this field is in an inactive case branch, just ignore it
-      discard
     elif fieldId == considerQuotedIdent(c, assignment[0]).id:
       return assignment
 
@@ -83,7 +79,7 @@ proc semConstrField(c: PContext, flags: TExprFlags,
     if nfSkipFieldChecking in assignment[1].flags:
       discard
     elif not fieldVisible(c, field):
-      localError(c.config, assignment[0].info,
+      localError(c.config, initExpr.info,
         "the field '$1' is not accessible." % [field.name.s])
       return
 
@@ -240,7 +236,7 @@ proc semConstructFields(c: PContext, n: PNode, constrCtx: var ObjConstrContext,
           let prevFields = fieldsPresentInBranch(selectedBranch)
           let currentFields = fieldsPresentInBranch(i)
           localError(c.config, constrCtx.initExpr.info,
-            ("The fields $1 and $2 cannot be initialized together, " &
+            ("The fields '$1' and '$2' cannot be initialized together, " &
             "because they are from conflicting branches in the case object.") %
             [prevFields, currentFields])
           result.status = initConflict
@@ -469,14 +465,11 @@ proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType
   if t == nil:
     return localErrorNode(c, result, "object constructor needs an object type")
 
-  when false:
-    # attempted type inference for generic object types,
-    # doesn't work since n[0] isn't set and seems underspecified
-    if t.skipTypes({tyGenericInst,
-        tyAlias, tySink, tyOwned, tyRef}).kind != tyObject and
-        expectedType != nil and expectedType.skipTypes({tyGenericInst,
-        tyAlias, tySink, tyOwned, tyRef}).kind == tyObject:
-      t = expectedType
+  if t.skipTypes({tyGenericInst,
+      tyAlias, tySink, tyOwned, tyRef}).kind != tyObject and
+      expectedType != nil and expectedType.skipTypes({tyGenericInst,
+      tyAlias, tySink, tyOwned, tyRef}).kind == tyObject:
+    t = expectedType
 
   t = skipTypes(t, {tyGenericInst, tyAlias, tySink, tyOwned})
   if t.kind == tyRef:
@@ -519,17 +512,13 @@ proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType
         invalidObjConstr(c, field)
         hasError = true
         continue
-      elif nfPreventCg in field.flags:
-        # this is an object constructor node generated by the VM and
-        # this field is in an inactive case branch, just ignore it
-        continue
       let id = considerQuotedIdent(c, field[0])
       # This node was not processed. There are two possible reasons:
       # 1) It was shadowed by a field with the same name on the left
       for j in 1..<i:
         let prevId = considerQuotedIdent(c, result[j][0])
         if prevId.id == id.id:
-          localError(c.config, field[0].info, errFieldInitTwice % id.s)
+          localError(c.config, field.info, errFieldInitTwice % id.s)
           hasError = true
           break
       # 2) No such field exists in the constructed type

compiler/sempass2.nim

@@ -84,9 +84,6 @@ type
     gcUnsafe, isRecursive, isTopLevel, hasSideEffect, inEnforcedGcSafe: bool
     isInnerProc: bool
     inEnforcedNoSideEffects: bool
-    isArrayIndexing: bool
-    currentExceptType: PType
-    unknownRaises: seq[(PSym, TLineInfo)]
     currOptions: TOptions
     optionsStack: seq[(TOptions, TNoteKinds)]
     config: ConfigRef
@@ -127,11 +124,10 @@ proc collectObjectTree(graph: ModuleGraph, n: PNode) =
             else:
               graph.objectTree[root].add (depthLevel, typ)
 
-proc createTypeBoundOps(tracked: PEffects, typ: PType; info: TLineInfo; explicit = false) =
-  if typ == nil or (sfGeneratedOp in tracked.owner.flags and not explicit):
+proc createTypeBoundOps(tracked: PEffects, typ: PType; info: TLineInfo) =
+  if typ == nil or sfGeneratedOp in tracked.owner.flags:
     # don't create type bound ops for anything in a function with a `nodestroy` pragma
     # bug #21987
-    # unless this is an explicit call, bug #24626
     return
   when false:
     let realType = typ.skipTypes(abstractInst)
@@ -148,37 +144,6 @@ proc isLocalSym(a: PEffects, s: PSym): bool =
   s.typ != nil and (s.kind in {skLet, skVar, skResult} or (s.kind == skParam and isOutParam(s.typ))) and
     sfGlobal notin s.flags and s.owner == a.owner
 
-proc isRangeSupertype(conf: ConfigRef; wider, narrower: PType): bool =
-  ## Check if `wider` type fully contains `narrower` type
-  ## Returns true if narrower fits entirely within wider (safe conversion)
-  if wider.isOrdinalType:
-    let wideFirst = firstOrd(conf, wider)
-    let wideLast = lastOrd(conf, wider)
-    let narrowFirst = firstOrd(conf, narrower)
-    let narrowLast = lastOrd(conf, narrower)
-    result = narrowFirst >= wideFirst and narrowLast <= wideLast
-  elif not narrower.isOrdinalType:
-    let wideFirst = firstFloat(wider)
-    let wideLast = lastFloat(wider)
-    let narrowFirst = firstFloat(narrower)
-    let narrowLast = lastFloat(narrower)
-    result = narrowFirst >= wideFirst and narrowLast <= wideLast
-  else:
-    # int -> float ranges; warn
-    result = false
-
-proc shouldWarnRangeConversion(conf: ConfigRef; formalType, argType: PType): bool =
-  ## Determine if an implicit range conversion should warn
-  ## We warn on conversions that are likely to cause panics
-  let f = formalType.skipTypes({tyGenericInst, tyAlias, tySink, tyDistinct})
-  let a = argType.skipTypes({tyGenericInst, tyAlias, tySink, tyDistinct})
-  if f.kind == tyRange:
-    # Only warn if formal range doesn't fully contain argument range
-    # Check if the ranges don't perfectly overlap
-    result = not isRangeSupertype(conf, f, a)
-  else:
-    result = false
-
 proc lockLocations(a: PEffects; pragma: PNode) =
   if pragma.kind != nkExprColonExpr:
     localError(a.config, pragma.info, "locks pragma without argument")
@@ -247,7 +212,6 @@ proc varDecl(a: PEffects; n: PNode) {.inline.} =
 proc skipHiddenDeref(n: PNode): PNode {.inline.} =
   result = if n.kind == nkHiddenDeref: n[0] else: n
 
-
 proc initVar(a: PEffects, n: PNode; volatileCheck: bool) =
   let n = skipHiddenDeref(n)
   if n.kind != nkSym: return
@@ -411,9 +375,7 @@ proc useVar(a: PEffects, n: PNode) =
       # If the variable is explicitly marked as .noinit. do not emit any error
       a.init.add s.id
     elif s.id notin a.init:
-      if s.kind == skResult and tfRequiresInit in s.typ.flags:
-        localError(a.config, n.info, "'result' requires explicit initialization")
-      elif s.typ.requiresInit:
+      if s.typ.requiresInit:
         message(a.config, n.info, warnProveInit, s.name.s)
       elif a.leftPartOfAsgn <= 0:
         if strictDefs in a.c.features:
@@ -609,25 +571,11 @@ proc trackTryStmt(tracked: PEffects, n: PNode) =
     let b = n[i]
     if b.kind == nkExceptBranch:
       setLen(tracked.init, oldState)
-      # If this except branch catches exactly one type, record it so an
-      # empty `raise` inside the branch can be inferred as re-raising that
-      # specific exception type instead of the generic `Exception`.
-      var savedExcept: PType = tracked.currentExceptType
-      var inferredExcept: PType = nil
-      if b.len == 2:
-        if b[0].isInfixAs():
-          assert(b[0][1].kind == nkType)
-          inferredExcept = b[0][1].typ
-        else:
-          assert(b[0].kind == nkType)
-          inferredExcept = b[0].typ
-      tracked.currentExceptType = inferredExcept
       for j in 0..<b.len - 1:
         if b[j].isInfixAs(): # skips initialization checks
           assert(b[j][2].kind == nkSym)
           tracked.init.add b[j][2].sym.id
       track(tracked, b[^1])
-      tracked.currentExceptType = savedExcept
       for i in oldState..<tracked.init.len:
         addToIntersection(inter, tracked.init[i], bsNone)
     else:
@@ -688,8 +636,6 @@ proc importedFromC(n: PNode): bool =
 proc propagateEffects(tracked: PEffects, n: PNode, s: PSym) =
   let pragma = s.ast[pragmasPos]
   let spec = effectSpec(pragma, wRaises)
-  if spec.isNil and sfForward in s.flags:
-    tracked.unknownRaises.add (s, n.info)
   mergeRaises(tracked, spec, n)
 
   let tagSpec = effectSpec(pragma, wTags)
@@ -753,7 +699,7 @@ proc isNoEffectList(n: PNode): bool {.inline.} =
   assert n.kind == nkEffectList
   n.len == 0 or (n[tagEffects] == nil and n[exceptionEffects] == nil and n[forbiddenEffects] == nil)
 
-proc isTrivial(caller: PNode): bool {.inline.} =
+proc isTrival(caller: PNode): bool {.inline.} =
   result = caller.kind == nkSym and caller.sym.magic in {mEqProc, mIsNil, mMove, mWasMoved, mSwap}
 
 proc trackOperandForIndirectCall(tracked: PEffects, n: PNode, formals: PType; argIndex: int; caller: PNode) =
@@ -762,7 +708,7 @@ proc trackOperandForIndirectCall(tracked: PEffects, n: PNode, formals: PType; ar
   let param = if formals != nil and formals.n != nil and argIndex < formals.n.len: formals.n[argIndex].sym else: nil
   # assume indirect calls are taken here:
   if op != nil and op.kind == tyProc and n.skipConv.kind != nkNilLit and
-      not isTrivial(caller) and
+      not isTrival(caller) and
       ((param != nil and sfEffectsDelayed in param.flags) or laxEffects in tracked.c.config.legacyFeatures):
 
     internalAssert tracked.config, op.n[0].kind == nkEffectList
@@ -934,9 +880,8 @@ proc trackIf(tracked: PEffects, n: PNode) =
   setLen(tracked.guards.s, oldFacts)
   dec tracked.inIfStmt
 
-proc trackBlock(tracked: PEffects, n: PNode; typ: PType) =
+proc trackBlock(tracked: PEffects, n: PNode) =
   if n.kind in {nkStmtList, nkStmtListExpr}:
-    let myBlock = tracked.currentBlock
     var oldState = -1
     for i in 0..<n.len:
       if hasSubnodeWith(n[i], nkBreakStmt):
@@ -948,14 +893,6 @@ proc trackBlock(tracked: PEffects, n: PNode; typ: PType) =
         if oldState < 0: oldState = tracked.init.len
       track(tracked, n[i])
     if oldState > 0: setLen(tracked.init, oldState)
-    if typ != nil and typ.kind in {tyVar, tyLent, tyOpenArray, tyVarargs}:
-      let last = lastSon(n)
-      let root = getRoot(last)
-      if root != nil:
-        let owner = tracked.scopes.getOrDefault(root.id, -1)
-        if owner >= 0:
-          localError(tracked.config, last.info, "'" & renderTree(last) & "' borrows from location '" & root.name.s &
-            "' which does not live long enough")
   else:
     track(tracked, n)
 
@@ -1028,7 +965,7 @@ proc checkForSink(tracked: PEffects; n: PNode) =
 proc markCaughtExceptions(tracked: PEffects; g: ModuleGraph; info: TLineInfo; s: PSym; usageSym: var PSym) =
   when defined(nimsuggest):
     proc internalMarkCaughtExceptions(tracked: PEffects; q: var SuggestFileSymbolDatabase; info: TLineInfo) =
-      var si = q.findSymInfoIndex(info, true)
+      var si = q.findSymInfoIndex(info)
       if si != -1:
         q.caughtExceptionsSet[si] = true
         for w1 in tracked.caughtExceptions.nodes:
@@ -1038,25 +975,6 @@ proc markCaughtExceptions(tracked: PEffects; g: ModuleGraph; info: TLineInfo; s:
     if optIdeExceptionInlayHints in tracked.config.globalOptions:
       internalMarkCaughtExceptions(tracked, g.suggestSymbols.mgetOrPut(info.fileIndex, newSuggestFileSymbolDatabase(info.fileIndex, true)), info)
 
-proc findHookKind(name: string): (bool, TTypeAttachedOp) =
-  case name.normalize
-  of "=wasmoved":
-    result = (true, attachedWasMoved)
-  of "=destroy":
-    result = (true, attachedDestructor)
-  of "=copy", "=":
-    result = (true, attachedAsgn)
-  of "=dup":
-    result = (true, attachedDup)
-  of "=sink":
-    result = (true, attachedSink)
-  of "=trace":
-    result = (true, attachedTrace)
-  of "=deepcopy":
-    result = (true, attachedDeepCopy)
-  else:
-    result = (false, attachedWasMoved)
-
 proc trackCall(tracked: PEffects; n: PNode) =
   template gcsafeAndSideeffectCheck() =
     if notGcSafe(op) and not importedFromC(a):
@@ -1145,17 +1063,18 @@ proc trackCall(tracked: PEffects; n: PNode) =
       checkBounds(tracked, n[1], n[2])
 
 
-  var n = n
   if a.kind == nkSym and a.sym.name.s.len > 0 and a.sym.name.s[0] == '=' and
         tracked.owner.kind != skMacro:
-    var (isHook, opKind) = findHookKind(a.sym.name.s)
-    if isHook:
+    var opKind = find(AttachedOpToStr, a.sym.name.s.normalize)
+    if a.sym.name.s == "=": opKind = attachedAsgn.int
+    if opKind != -1:
       # rebind type bounds operations after createTypeBoundOps call
       let t = n[1].typ.skipTypes({tyAlias, tyVar})
-      if a.sym != getAttachedOp(tracked.graph, t, opKind):
-        createTypeBoundOps(tracked, t, n.info, explicit = true)
-        # replace builtin hooks with lifted ones
-        n = replaceHookMagic(tracked.c, n, opKind)
+      if a.sym != getAttachedOp(tracked.graph, t, TTypeAttachedOp(opKind)):
+        createTypeBoundOps(tracked, t, n.info)
+        let op = getAttachedOp(tracked.graph, t, TTypeAttachedOp(opKind))
+        if op != nil:
+          n[0].sym = op
 
   if op != nil and op.kind == tyProc:
     for i in 1..<min(n.safeLen, op.signatureLen):
@@ -1310,14 +1229,7 @@ proc track(tracked: PEffects, n: PNode) =
       # A `raise` with no arguments means we're going to re-raise the exception
       # being handled or, if outside of an `except` block, a `ReraiseDefect`.
       # Here we add a `Exception` tag in order to cover both the cases.
-      if tracked.currentExceptType != nil:
-        var en = newNode(nkType)
-        en.typ = tracked.currentExceptType
-        en.info = n.info
-        addRaiseEffect(tracked, en, nil)
-        createTypeBoundOps(tracked, tracked.currentExceptType, n.info)
-      else:
-        addRaiseEffect(tracked, createRaise(tracked.graph, n), nil)
+      addRaiseEffect(tracked, createRaise(tracked.graph, n), nil)
   of nkCallKinds:
     trackCall(tracked, n)
   of nkDotExpr:
@@ -1389,18 +1301,13 @@ proc track(tracked: PEffects, n: PNode) =
       let last = lastSon(child)
       track(tracked, last)
   of nkCaseStmt: trackCase(tracked, n)
-  of nkWhen: # This should be a "when nimvm" node.
-    let oldState = tracked.init.len
-    track(tracked, n[0][1])
-    tracked.init.setLen(oldState)
-    track(tracked, n[1][0])
-  of nkIfStmt, nkIfExpr: trackIf(tracked, n)
-  of nkBlockStmt, nkBlockExpr: trackBlock(tracked, n[1], n.typ)
+  of nkWhen, nkIfStmt, nkIfExpr: trackIf(tracked, n)
+  of nkBlockStmt, nkBlockExpr: trackBlock(tracked, n[1])
   of nkWhileStmt:
     # 'while true' loop?
     inc tracked.currentBlock
     if isTrue(n[0]):
-      trackBlock(tracked, n[1], nil)
+      trackBlock(tracked, n[1])
     else:
       # loop may never execute:
       let oldState = tracked.init.len
@@ -1535,11 +1442,6 @@ proc track(tracked: PEffects, n: PNode) =
       message(tracked.config, n.info, warnPtrToCstringConv,
           $n[1].typ)
 
-    # Check for implicit range conversions
-    if n.kind == nkHiddenStdConv and (not tracked.isArrayIndexing) and
-          shouldWarnRangeConversion(tracked.config, n.typ, n[1].typ):
-      message(tracked.config, n.info, warnImplicitRangeConversion,
-              typeToString(n[1].typ) & " -> " & typeToString(n.typ))
 
     let t = n.typ.skipTypes(abstractInst)
     if t.kind == tyEnum:
@@ -1578,12 +1480,7 @@ proc track(tracked: PEffects, n: PNode) =
         checkBounds(tracked, n[0], n[1])
     track(tracked, n[0])
     dec tracked.leftPartOfAsgn
-    for i in 1 ..< n.len:
-      if i == 1:
-        tracked.isArrayIndexing = true
-      track(tracked, n[i])
-      if i == 1:
-        tracked.isArrayIndexing = false
+    for i in 1 ..< n.len: track(tracked, n[i])
     inc tracked.leftPartOfAsgn
   of nkError:
     localError(tracked.config, n.info, errorToString(tracked.config, n))
@@ -1601,7 +1498,7 @@ proc subtypeRelation(g: ModuleGraph; spec, real: PNode): bool =
 
 proc checkRaisesSpec(g: ModuleGraph; emitWarnings: bool; spec, real: PNode, msg: string, hints: bool;
                      effectPredicate: proc (g: ModuleGraph; a, b: PNode): bool {.nimcall.};
-                     hintsArg: PNode = nil; isForbids: bool = false; unknownRaises: seq[(PSym, TLineInfo)] = @[]) =
+                     hintsArg: PNode = nil; isForbids: bool = false) =
   # check that any real exception is listed in 'spec'; mark those as used;
   # report any unused exception
   var used = initIntSet()
@@ -1618,8 +1515,6 @@ proc checkRaisesSpec(g: ModuleGraph; emitWarnings: bool; spec, real: PNode, msg:
       pushInfoContext(g.config, spec.info)
       var rr = if r.kind == nkRaiseStmt: r[0] else: r
       while rr.kind in {nkStmtList, nkStmtListExpr} and rr.len > 0: rr = rr.lastSon
-      for (s, info) in unknownRaises.items:
-        message(g.config, info, hintUnknownRaises, s.name.s)
       message(g.config, r.info, if emitWarnings: warnEffect else: errGenerated,
               renderTree(rr) & " " & msg & typeToString(r.typ))
       popInfoContext(g.config)
@@ -1743,9 +1638,6 @@ proc trackProc*(c: PContext; s: PSym, body: PNode) =
      s.kind in {skProc, skFunc, skConverter, skMethod}:
     var res = s.ast[resultPos].sym # get result symbol
     t.scopes[res.id] = t.currentBlock
-    if sfNoInit in s.flags:
-      # marks result "noinit"
-      incl res.flags, sfNoInit
 
   track(t, body)
 
@@ -1758,14 +1650,13 @@ proc trackProc*(c: PContext; s: PSym, body: PNode) =
           (t.config.selectedGC in {gcArc, gcOrc, gcAtomicArc} and
             (isClosure(typ.skipTypes(abstractInst)) or param.id in t.escapingParams)):
         createTypeBoundOps(t, typ, param.info)
-      if isOutParam(typ) and param.id notin t.init and s.magic == mNone:
+      if isOutParam(typ) and param.id notin t.init:
         message(g.config, param.info, warnProveInit, param.name.s)
 
   if not isEmptyType(s.typ.returnType) and
      (s.typ.returnType.requiresInit or s.typ.returnType.skipTypes(abstractInst).kind == tyVar or
        strictDefs in c.features) and
-     s.kind in {skProc, skFunc, skConverter, skMethod} and s.magic == mNone and
-     sfNoInit notin s.flags:
+     s.kind in {skProc, skFunc, skConverter, skMethod} and s.magic == mNone:
     var res = s.ast[resultPos].sym # get result symbol
     if res.id notin t.init and breaksBlock(body) != bsNoReturn:
       if tfRequiresInit in s.typ.returnType.flags:
@@ -1777,7 +1668,7 @@ proc trackProc*(c: PContext; s: PSym, body: PNode) =
   if not isNil(raisesSpec):
     let useWarning = s.name.s == "=destroy"
     checkRaisesSpec(g, useWarning, raisesSpec, t.exc, "can raise an unlisted exception: ",
-                    hints=on, subtypeRelation, hintsArg=s.ast[0], unknownRaises = t.unknownRaises)
+                    hints=on, subtypeRelation, hintsArg=s.ast[0])
     # after the check, use the formal spec:
     effects[exceptionEffects] = raisesSpec
   else:

compiler/semstmts.nim

@@ -394,9 +394,8 @@ proc semTry(c: PContext, n: PNode; flags: TExprFlags; expectedType: PType = nil)
       elif a.len == 1:
         # count number of ``except: body`` blocks
         inc catchAllExcepts
-        if noPanicOnExcept in c.graph.config.legacyFeatures:
-          message(c.config, a.info, warnBareExcept,
-                    "The bare except clause is deprecated; use `except CatchableError:` instead")
+        message(c.config, a.info, warnBareExcept,
+                  "The bare except clause is deprecated; use `except CatchableError:` instead")
       else:
         # support ``except KeyError, ValueError, ... : body``
         if catchAllExcepts > 0:
@@ -493,8 +492,19 @@ proc semIdentDef(c: PContext, n: PNode, kind: TSymKind, reportToNimsuggest = tru
       incl(result.flags, sfGlobal)
   result.options = c.config.options
 
+  proc getLineInfo(n: PNode): TLineInfo =
+    case n.kind
+    of nkPostfix:
+      if len(n) > 1:
+        return getLineInfo(n[1])
+    of nkAccQuoted, nkPragmaExpr:
+      if len(n) > 0:
+        return getLineInfo(n[0])
+    else:
+      discard
+    result = n.info
+  let info = getLineInfo(n)
   if reportToNimsuggest:
-    let info = getLineInfo(n)
     suggestSym(c.graph, info, result, c.graph.usageSym)
 
 proc checkNilable(c: PContext; v: PSym) =
@@ -602,38 +612,11 @@ proc fillPartialObject(c: PContext; n: PNode; typ: PType) =
   else:
     localError(c.config, n.info, "nkDotNode requires 2 children")
 
-proc checkDefineType(c: PContext; v: PSym; t: PType) =
-  # see semfold.foldDefine for acceptable types
-  let typeKinds =
-    case v.magic
-    of mStrDefine: {tyString, tyCstring}
-    # this used to be not typechecked, so anything that accepts int nodes for compatbility:
-    of mIntDefine: {tyInt..tyInt64, tyUInt..tyUInt64, tyBool, tyChar, tyEnum}
-    of mBoolDefine: {tyBool}
-    of mGenericDefine: {tyString, tyCstring, tyInt..tyInt64, tyUInt..tyUInt64, tyBool, tyEnum}
-    else: raiseAssert("unreachable")
-  var skipped = abstractVarRange
-  if v.magic == mGenericDefine:
-    # no distinct types for generic define
-    skipped.excl tyDistinct
-  if t.skipTypes(skipped).kind notin typeKinds:
-    let name =
-      case v.magic
-      of mStrDefine: "strdefine"
-      of mIntDefine: "intdefine"
-      of mBoolDefine: "booldefine"
-      of mGenericDefine: "define"
-      else: raiseAssert("unreachable")
-    localError(c.config, v.info, "unsupported type for constant '" & v.name.s &
-      "' with ." & name & " pragma: " & typeToString(t))
-
 proc setVarType(c: PContext; v: PSym, typ: PType) =
   if v.typ != nil and not sameTypeOrNil(v.typ, typ):
     localError(c.config, v.info, "inconsistent typing for reintroduced symbol '" &
         v.name.s & "': previous type was: " & typeToString(v.typ, preferDesc) &
         "; new type is: " & typeToString(typ, preferDesc))
-  if v.kind == skConst and v.magic in {mGenericDefine, mIntDefine, mStrDefine, mBoolDefine}:
-    checkDefineType(c, v, typ)
   v.typ = typ
 
 proc isPossibleMacroPragma(c: PContext, it: PNode, key: PNode): bool =
@@ -726,33 +709,22 @@ template isLocalSym(sym: PSym): bool =
       sym.typ.kind == tyTypeDesc or
       sfCompileTime in sym.flags) or
       sym.kind in {skProc, skFunc, skIterator} and
-      sfGlobal notin sym.flags and sym.typ.callConv == ccClosure
+      sfGlobal notin sym.flags
+
+template isLocalVarSym(n: PNode): bool =
+  n.kind == nkSym and isLocalSym(n.sym)
 
 proc usesLocalVar(n: PNode): bool =
-  case n.kind
-  of nkSym:
-    result = isLocalSym(n.sym)
-  of nkCallKinds, nkObjConstr:
-    result = false
-    for i in 1 ..< n.len:
-      if usesLocalVar(n[i]):
+  result = false
+  for z in 1 ..< n.len:
+    if n[z].isLocalVarSym:
+      return true
+    elif n[z].kind in nkCallKinds:
+      if usesLocalVar(n[z]):
         return true
-  of nkTupleConstr, nkPar, nkBracket, nkCurly:
-    result = false
-    for i in 0 ..< n.len:
-      if usesLocalVar(n[i]):
-        return true
-  of nkDotExpr, nkCheckedFieldExpr,
-       nkBracketExpr, nkAddr, nkHiddenAddr,
-       nkObjDownConv, nkObjUpConv:
-    result = usesLocalVar(n[0])
-  of nkHiddenStdConv, nkHiddenSubConv, nkCast, nkExprColonExpr:
-    result = usesLocalVar(n[1])
-  else:
-    result = false
 
 proc globalVarInitCheck(c: PContext, n: PNode) =
-  if usesLocalVar(n):
+  if n.isLocalVarSym or n.kind in nkCallKinds and usesLocalVar(n):
     localError(c.config, n.info, errCannotAssignToGlobal)
 
 const
@@ -1726,14 +1698,12 @@ proc typeSectionRightSidePass(c: PContext, n: PNode) =
         obj.ast[0] = a[0].shallowCopy
         if a[0][0].kind == nkPostfix:
           obj.ast[0][0] = a[0][0].shallowCopy
-          obj.ast[0][0][0] = a[0][0][0] # ident "*"
           obj.ast[0][0][1] = symNode
         else:
           obj.ast[0][0] = symNode
         obj.ast[0][1] = a[0][1]
       of nkPostfix:
         obj.ast[0] = a[0].shallowCopy
-        obj.ast[0][0] = a[0][0] # ident "*"
         obj.ast[0][1] = symNode
       else: assert(false)
       obj.ast[1] = a[1]
@@ -1788,17 +1758,6 @@ proc typeSectionFinalPass(c: PContext, n: PNode) =
     # check the style here after the pragmas have been processed:
     styleCheckDef(c, s)
     # compute the type's size and check for illegal recursions:
-    if a[0].kind == nkPragmaExpr:
-      let pragmas = a[0][1]
-      for i in 0 ..< pragmas.len:
-        if pragmas[i].kind == nkExprColonExpr and
-            pragmas[i][0].kind == nkIdent and
-            whichKeyword(pragmas[i][0].ident) == wSize:
-          if s.typ.kind != tyEnum and sfImportc notin s.flags:
-            # EventType* {.size: sizeof(uint32).} = enum
-            # AtomicFlag* {.importc: "atomic_flag", header: "<stdatomic.h>", size: 1.} = object
-            localError(c.config, pragmas[i].info, "size pragma only allowed for enum types and imported types")
-
     if a[1].kind == nkEmpty:
       var x = a[2]
       if x.kind in nkCallKinds and nfSem in x.flags:
@@ -1829,13 +1788,6 @@ proc typeSectionFinalPass(c: PContext, n: PNode) =
            x[0].kind in {nkObjectTy, nkTupleTy})
           ):
           checkForMetaFields(c, baseType.n, hasError)
-
-        if s.typ.kind in {tySet, tyArray, tySequence, tyUncheckedArray} and s.typ.elementType.kind == tyNone:
-          # magic generics are not filled but tyNone is added to its elements by default,
-          # we lift them to tyBuiltInTypeClass here
-          s.typ = newTypeS(tyBuiltInTypeClass, c,
-                    newTypeS(s.typ.kind, c))
-
         if not hasError:
           checkConstructedType(c.config, s.info, s.typ)
   #instAllTypeBoundOp(c, n.info)
@@ -2083,27 +2035,14 @@ proc canonType(c: PContext, t: PType): PType =
   else:
     result = t
 
-proc prevDestructor(c: PContext; op: TTypeAttachedOp; prevOp: PSym; obj: PType; info: TLineInfo) =
-  var msg = "cannot bind another '" & AttachedOpToStr[op] & "' to: " & typeToString(obj)
-  if prevOp == nil:
-    # happens if the destructor was implicitly constructed for a specific instance,
-    # not the entire generic type
-    msg.add "; previous declaration was constructed implicitly"
-  elif sfOverridden notin prevOp.flags:
+proc prevDestructor(c: PContext; prevOp: PSym; obj: PType; info: TLineInfo) =
+  var msg = "cannot bind another '" & prevOp.name.s & "' to: " & typeToString(obj)
+  if sfOverridden notin prevOp.flags:
     msg.add "; previous declaration was constructed here implicitly: " & (c.config $ prevOp.info)
   else:
     msg.add "; previous declaration was here: " & (c.config $ prevOp.info)
   localError(c.config, info, errGenerated, msg)
 
-proc checkedForDestructor(t: PType): bool =
-  if tfCheckedForDestructor in t.flags:
-    return true
-  # maybe another instance was instantiated, marking the generic root:
-  let root = genericRoot(t)
-  if root != nil and tfGenericHasDestructor in root.flags:
-    return true
-  result = false
-
 proc whereToBindTypeHook(c: PContext; t: PType): PType =
   result = t
   while true:
@@ -2137,10 +2076,10 @@ proc bindDupHook(c: PContext; s: PSym; n: PNode; op: TTypeAttachedOp) =
       let ao = getAttachedOp(c.graph, obj, op)
       if ao == s:
         discard "forward declared destructor"
-      elif ao.isNil and not checkedForDestructor(obj):
+      elif ao.isNil and tfCheckedForDestructor notin obj.flags:
         setAttachedOp(c.graph, c.module.position, obj, op, s)
       else:
-        prevDestructor(c, op, ao, obj, n.info)
+        prevDestructor(c, ao, obj, n.info)
       noError = true
       if obj.owner.getModule != s.getModule:
         localError(c.config, n.info, errGenerated,
@@ -2153,20 +2092,16 @@ 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
-  template notRefc: bool =
-    # fixes refc with non-var destructor; cancel warnings (#23156)
-    c.config.backend == backendJs or
-      c.config.selectedGC in {gcArc, gcAtomicArc, gcOrc}
   let cond = case op
              of attachedWasMoved:
                t.len == 2 and t.returnType == nil and t.firstParamType.kind == tyVar
              of attachedTrace:
                t.len == 3 and t.returnType == nil and t.firstParamType.kind == tyVar and t[2].kind == tyPointer
              of attachedDestructor:
-               if notRefc:
+               if c.config.selectedGC in {gcArc, gcAtomicArc, gcOrc}:
                  t.len == 2 and t.returnType == nil
                else:
                  t.len == 2 and t.returnType == nil and t.firstParamType.kind == tyVar
@@ -2181,14 +2116,17 @@ 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 (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)
       let ao = getAttachedOp(c.graph, obj, op)
       if ao == s:
         discard "forward declared destructor"
-      elif ao.isNil and not checkedForDestructor(obj):
+      elif ao.isNil and tfCheckedForDestructor notin obj.flags:
         setAttachedOp(c.graph, c.module.position, obj, op, s)
       else:
-        prevDestructor(c, op, ao, obj, n.info)
+        prevDestructor(c, ao, obj, n.info)
       noError = true
       if obj.owner.getModule != s.getModule:
         localError(c.config, n.info, errGenerated,
@@ -2199,7 +2137,7 @@ proc bindTypeHook(c: PContext; s: PSym; n: PNode; op: TTypeAttachedOp) =
       localError(c.config, n.info, errGenerated,
         "signature for '=trace' must be proc[T: object](x: var T; env: pointer)")
     of attachedDestructor:
-      if notRefc:
+      if c.config.selectedGC in {gcArc, gcAtomicArc, gcOrc}:
         localError(c.config, n.info, errGenerated,
           "signature for '=destroy' must be proc[T: object](x: var T) or proc[T: object](x: T)")
       else:
@@ -2279,10 +2217,10 @@ proc semOverride(c: PContext, s: PSym, n: PNode) =
         let ao = getAttachedOp(c.graph, obj, k)
         if ao == s:
           discard "forward declared op"
-        elif ao.isNil and not checkedForDestructor(obj):
+        elif ao.isNil and tfCheckedForDestructor notin obj.flags:
           setAttachedOp(c.graph, c.module.position, obj, k, s)
         else:
-          prevDestructor(c, k, ao, obj, n.info)
+          prevDestructor(c, ao, obj, n.info)
         if obj.owner.getModule != s.getModule:
           localError(c.config, n.info, errGenerated,
             "type bound operation `" & name & "` can be defined only in the same module with its type (" & obj.typeToString() & ")")
@@ -2371,7 +2309,7 @@ proc semCppMember(c: PContext; s: PSym; n: PNode) =
           isInitializer = false
           break
         var j = 0
-        while p[j].kind == nkSym and p[j].sym.kind == skParam:
+        while p[j].sym.kind == skParam:
           initializerCall.add val
           inc j
       if isInitializer:
@@ -2421,7 +2359,6 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
   of nkEmpty:
     s = newSym(kind, c.cache.idAnon, c.idgen, c.getCurrOwner, n.info)
     s.flags.incl sfUsed
-    s.flags.incl sfGenSym
     n[namePos] = newSymNode(s)
   of nkSym:
     s = n[namePos].sym
@@ -2636,18 +2573,9 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
           else:
             nil
         # semantic checking also needed with importc in case used in VM
-
-        let isInlineIterator = isInlineIterator(s.typ)
         s.ast[bodyPos] = hloBody(c, semProcBody(c, n[bodyPos], resultType))
         # unfortunately we cannot skip this step when in 'system.compiles'
         # context as it may even be evaluated in 'system.compiles':
-
-        if isInlineIterator and s.typ.callConv == ccClosure:
-          # iterators without explicit callconvs are lifted to closure,
-          # we need to add a result symbol for them
-          maybeAddResult(c, s, n)
-
-
         trackProc(c, s, s.ast[bodyPos])
       else:
         if (s.typ.returnType != nil and s.kind != skIterator):
@@ -2719,7 +2647,7 @@ proc semIterator(c: PContext, n: PNode): PNode =
     incl(s.typ.flags, tfCapturesEnv)
   else:
     s.typ.callConv = ccInline
-  if result[bodyPos].kind == nkEmpty and s.magic == mNone and c.inConceptDecl == 0:
+  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)
@@ -2833,24 +2761,9 @@ proc recursiveSetFlag(n: PNode, flag: TNodeFlag) =
     for i in 0..<n.safeLen: recursiveSetFlag(n[i], flag)
     incl(n.flags, flag)
 
-proc enterPragmaBlock(c: PContext): POptionEntry =
-  result = POptionEntry(options: c.config.options,
-    notes: c.config.notes,
-    warningAsErrors: c.config.warningAsErrors,
-    features: c.features)
-
-proc leavePragmaBlock(c: PContext, p: POptionEntry) =
-  c.config.options = p.options
-  c.config.notes = p.notes
-  c.config.warningAsErrors = p.warningAsErrors
-  c.features = p.features
-
 proc semPragmaBlock(c: PContext, n: PNode; expectedType: PType = nil): PNode =
   checkSonsLen(n, 2, c.config)
   let pragmaList = n[0]
-
-  let oldOptionEntry = enterPragmaBlock(c)
-
   pragma(c, nil, pragmaList, exprPragmas, isStatement = true)
 
   var inUncheckedAssignSection = 0
@@ -2875,8 +2788,6 @@ proc semPragmaBlock(c: PContext, n: PNode; expectedType: PType = nil): PNode =
     of wNoRewrite: recursiveSetFlag(result, nfNoRewrite)
     else: discard
 
-  leavePragmaBlock(c, oldOptionEntry)
-
 proc semStaticStmt(c: PContext, n: PNode): PNode =
   #echo "semStaticStmt"
   #writeStackTrace()

compiler/semtempl.nim

@@ -67,9 +67,7 @@ proc symChoice(c: PContext, n: PNode, s: PSym, r: TSymChoiceRule;
     # for instance 'nextTry' is both in tables.nim and astalgo.nim ...
     if not isField or sfGenSym notin s.flags:
       result = newSymNode(s, info)
-      # possibly not final field sym
-      incl(s.flags, sfUsed)
-      markOwnerModuleAsUsed(c, s)
+      markUsed(c, info, s)
       onUse(info, s)
     else:
       result = n
@@ -693,9 +691,6 @@ proc semTemplateDef(c: PContext, n: PNode): PNode =
     s = semIdentVis(c, skTemplate, n[namePos], {})
   assert s.kind == skTemplate
 
-  let info = getLineInfo(n[namePos])
-  suggestSym(c.graph, info, s, c.graph.usageSym)
-
   styleCheckDef(c, s)
   onDef(n[namePos].info, s)
   # check parameter list:

compiler/semtypes.nim

@@ -38,27 +38,21 @@ const
   errNoGenericParamsAllowedForX = "no generic parameters allowed for $1"
   errInOutFlagNotExtern = "the '$1' modifier can be used only with imported types"
 
-proc reusePrev(prev: PType): bool {.inline.} =
-  # only overwrite `prev` if it is a forward type, partial object or magic type
-  result = prev != nil and (prev.kind == tyForward or (prev.sym != nil and
-    # partial object marks sym as `sfForward`
-    (sfForward in prev.sym.flags or prev.sym.magic != mNone)))
-
 proc newOrPrevType(kind: TTypeKind, prev: PType, c: PContext, son: sink PType): PType =
-  if reusePrev(prev):
+  if prev == nil or prev.kind == tyGenericBody:
+    result = newTypeS(kind, c, son)
+  else:
     result = prev
     result.setSon(son)
     if result.kind == tyForward: result.kind = kind
-  else:
-    result = newTypeS(kind, c, son)
   #if kind == tyError: result.flags.incl tfCheckedForDestructor
 
 proc newOrPrevType(kind: TTypeKind, prev: PType, c: PContext): PType =
-  if reusePrev(prev):
+  if prev == nil or prev.kind == tyGenericBody:
+    result = newTypeS(kind, c)
+  else:
     result = prev
     if result.kind == tyForward: result.kind = kind
-  else:
-    result = newTypeS(kind, c)
 
 proc newConstraint(c: PContext, k: TTypeKind): PType =
   result = newTypeS(tyBuiltInTypeClass, c)
@@ -90,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
@@ -129,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:
@@ -182,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:
@@ -263,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 =
@@ -415,12 +387,8 @@ proc semArrayIndex(c: PContext, n: PNode): PType =
       result = makeRangeWithStaticExpr(c, e.typ.n)
     elif e.kind in {nkIntLit..nkUInt64Lit}:
       if e.intVal < 0:
-        if e.kind in {nkIntLit..nkInt64Lit}:
-          localError(c.config, n.info,
-            "Array length can't be negative, but was " & $e.intVal)
-        else:
-          localError(c.config, n.info,
-            "Array length can't exceed its maximum value (9223372036854775807), but was " & $cast[BiggestUInt](e.intVal))
+        localError(c.config, n.info,
+          "Array length can't be negative, but was " & $e.intVal)
       result = makeRangeType(c, 0, e.intVal-1, n.info, e.typ)
     elif e.kind == nkSym and (e.typ.kind == tyStatic or e.typ.kind == tyTypeDesc):
       if e.typ.kind == tyStatic:
@@ -526,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.skipIntLit(c.idgen)
+      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:
@@ -559,7 +520,7 @@ proc semTuple(c: PContext, n: PNode, prev: PType): PType =
       styleCheckDef(c, a[j].info, field)
       onDef(field.info, field)
   if result.n.len == 0: result.n = nil
-  if isRecursiveStructuralType(result):
+  if isTupleRecursive(result):
     localError(c.config, n.info, errIllegalRecursionInTypeX % typeToString(result))
 
 proc semIdentVis(c: PContext, kind: TSymKind, n: PNode,
@@ -790,7 +751,7 @@ proc semRecordCase(c: PContext, n: PNode, check: var IntSet, pos: var int,
   case typ.kind
   of shouldChckCovered:
     chckCovered = true
-  of tyError:
+  of tyFloat..tyFloat128, tyError:
     discard
   of tyRange:
     if skipTypes(typ.elementType, abstractInst).kind in shouldChckCovered:
@@ -798,8 +759,7 @@ proc semRecordCase(c: PContext, n: PNode, check: var IntSet, pos: var int,
   of tyForward:
     errorUndeclaredIdentifier(c, n[0].info, typ.sym.name.s)
   elif not isOrdinalType(typ):
-    localError(c.config, n[0].info, "selector must be of an ordinal type")
-
+    localError(c.config, n[0].info, "selector must be of an ordinal type, float")
   if firstOrd(c.config, typ) != 0:
     localError(c.config, n.info, "low(" & $a[0].sym.name.s &
                                      ") must be 0 for discriminant")
@@ -898,15 +858,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.skipIntLit(c.idgen)
-        propagateToOwner(rectype, typ)
+      typ = fitDefaultNode(c, n)
+      propagateToOwner(rectype, typ)
     elif n[^2].kind == nkEmpty:
       localError(c.config, n.info, errTypeExpected)
       typ = errorType(c)
@@ -986,7 +939,7 @@ proc skipGenericInvocation(t: PType): PType {.inline.} =
 proc tryAddInheritedFields(c: PContext, check: var IntSet, pos: var int,
                         obj: PType, n: PNode, isPartial = false, innerObj: PType = nil): bool =
   if ((not isPartial) and (obj.kind notin {tyObject, tyGenericParam} or tfFinal in obj.flags)) or
-    (innerObj != nil and obj.id == innerObj.id):
+    (innerObj != nil and obj.sym.id == innerObj.sym.id):
     localError(c.config, n.info, "Cannot inherit from: '" & $obj & "'")
     result = false
   elif obj.kind == tyObject:
@@ -1109,9 +1062,7 @@ proc semAnyRef(c: PContext; n: PNode; kind: TTypeKind; prev: PType): PType =
       let t = newTypeS(tySink, c, result)
       result = t
     else: discard
-    if result.kind == tyRef and
-        c.config.selectedGC in {gcArc, gcOrc, gcAtomicArc} and
-        tfTriggersCompileTime notin result.flags:
+    if result.kind == tyRef and c.config.selectedGC in {gcArc, gcOrc, gcAtomicArc}:
       result.flags.incl tfHasAsgn
 
 proc findEnforcedStaticType(t: PType): PType =
@@ -1298,14 +1249,12 @@ proc liftParamType(c: PContext, procKind: TSymKind, genericParams: PNode,
         paramType[i] = lifted
         result = paramType
         result.last.shouldHaveMeta
-    if paramType.isConcept:
-      return addImplicitGeneric(c, paramType, paramTypId, info, genericParams, paramName)
-    else:
-      let liftBody = recurse(paramType.skipModifier, true)
-      if liftBody != nil:
-        result = liftBody
-        result.flags.incl tfHasMeta
-        #result.shouldHaveMeta
+
+    let liftBody = recurse(paramType.skipModifier, true)
+    if liftBody != nil:
+      result = liftBody
+      result.flags.incl tfHasMeta
+      #result.shouldHaveMeta
 
   of tyGenericInvocation:
     result = nil
@@ -1319,6 +1268,7 @@ proc liftParamType(c: PContext, procKind: TSymKind, genericParams: PNode,
       # this may happen for proc type appearing in a type section
       # before one of its param types
       return
+
     if body.last.kind == tyUserTypeClass:
       let expanded = instGenericContainer(c, info, paramType,
                                           allowMetaTypes = true)
@@ -1475,8 +1425,6 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
       if isType: localError(c.config, a.info, "':' expected")
       if kind in {skTemplate, skMacro}:
         typ = newTypeS(tyUntyped, c)
-    elif isRecursiveStructuralType(typ):
-      localError(c.config, a[^2].info, errIllegalRecursionInTypeX % typeToString(typ))
     elif skipTypes(typ, {tyGenericInst, tyAlias, tySink}).kind == tyVoid:
       continue
 
@@ -1513,10 +1461,7 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
       addParamOrResult(c, arg, kind)
       styleCheckDef(c, a[j].info, arg)
       onDef(a[j].info, arg)
-      if a[j].kind == nkPragmaExpr:
-        a[j][0] = newSymNode(arg)
-      else:
-        a[j] = newSymNode(arg)
+      a[j] = newSymNode(arg)
 
   var r: PType = nil
   if n[0].kind != nkEmpty:
@@ -1540,9 +1485,7 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
   if r != nil:
     # turn explicit 'void' return type into 'nil' because the rest of the
     # compiler only checks for 'nil':
-    if isRecursiveStructuralType(r):
-      localError(c.config, n.info, errIllegalRecursionInTypeX % typeToString(r))
-    elif skipTypes(r, {tyGenericInst, tyAlias, tySink}).kind != tyVoid:
+    if skipTypes(r, {tyGenericInst, tyAlias, tySink}).kind != tyVoid:
       if kind notin {skMacro, skTemplate} and r.kind in {tyTyped, tyUntyped}:
         localError(c.config, n[0].info, "return type '" & typeToString(r) &
             "' is only valid for macros and templates")
@@ -1688,11 +1631,6 @@ proc semGeneric(c: PContext, n: PNode, s: PSym, prev: PType): PType =
       var err = "cannot instantiate "
       err.addTypeHeader(c.config, t)
       err.add "\ngot: <$1>\nbut expected: <$2>" % [describeArgs(c, n), describeArgs(c, t.n, 0)]
-      if m.firstMismatch.kind == kTypeMismatch and m.firstMismatch.arg < n.len:
-        let nArg = n[m.firstMismatch.arg]
-        if nArg.kind in nkSymChoices:
-          err.add "\n"
-          err.add ambiguousIdentifierMsg(nArg)
       localError(c.config, n.info, errGenerated, err)
       return newOrPrevType(tyError, prev, c)
 
@@ -1729,7 +1667,7 @@ proc semGeneric(c: PContext, n: PNode, s: PSym, prev: PType): PType =
   # special check for generic object with
   # generic/partial specialized parent
   let tx = result.skipTypes(abstractPtrs, 50)
-  if tx.isNil or isRecursiveStructuralType(tx):
+  if tx.isNil or isTupleRecursive(tx):
     localError(c.config, n.info, "illegal recursion in type '$1'" % typeToString(result[0]))
     return errorType(c)
   if tx != result and tx.kind == tyObject:
@@ -1750,10 +1688,10 @@ proc maybeAliasType(c: PContext; typeExpr, prev: PType): PType =
   else:
     result = nil
 
-proc fixupTypeOf(c: PContext, prev: PType, typ: PType) =
+proc fixupTypeOf(c: PContext, prev: PType, typExpr: PNode) =
   if prev != nil:
     let result = newTypeS(tyAlias, c)
-    result.rawAddSon typ
+    result.rawAddSon typExpr.typ
     result.sym = prev.sym
     if prev.kind != tyGenericBody:
       assignType(prev, result)
@@ -1893,7 +1831,7 @@ proc applyTypeSectionPragmas(c: PContext; pragmas, operand: PNode): PNode =
           x.add(operand.copyTreeWithoutNode(p))
           # recursion assures that this works for multiple macro annotations too:
           var r = semOverloadedCall(c, x, x, {skMacro, skTemplate}, {efNoUndeclared})
-          if r != nil and (r.typ == nil or r.typ.kind != tyFromExpr):
+          if r != nil:
             doAssert r[0].kind == nkSym
             let m = r[0].sym
             case m.kind
@@ -1945,19 +1883,12 @@ proc semTypeOf(c: PContext; n: PNode; prev: PType): PType =
   openScope(c)
   inc c.inTypeofContext
   defer: dec c.inTypeofContext # compiles can raise an exception
-  let ex = semExprWithType(c, n, {efInTypeof})
+  let t = semExprWithType(c, n, {efInTypeof})
   closeScope(c)
-  result = ex.typ
+  fixupTypeOf(c, prev, t)
+  result = t.typ
   if result.kind == tyFromExpr:
     result.flags.incl tfNonConstExpr
-  elif result.kind == tyStatic:
-    let base = result.skipTypes({tyStatic})
-    if c.inGenericContext > 0 and base.containsGenericType:
-      result = makeTypeFromExpr(c, copyTree(ex))
-      result.flags.incl tfNonConstExpr
-    else:
-      result = base
-  fixupTypeOf(c, prev, result)
 
 proc semTypeOf2(c: PContext; n: PNode; prev: PType): PType =
   openScope(c)
@@ -1970,19 +1901,12 @@ proc semTypeOf2(c: PContext; n: PNode; prev: PType): PType =
       m = mode.intVal
   inc c.inTypeofContext
   defer: dec c.inTypeofContext # compiles can raise an exception
-  let ex = semExprWithType(c, n[1], if m == 1: {efInTypeof} else: {})
+  let t = semExprWithType(c, n[1], if m == 1: {efInTypeof} else: {})
   closeScope(c)
-  result = ex.typ
+  fixupTypeOf(c, prev, t)
+  result = t.typ
   if result.kind == tyFromExpr:
     result.flags.incl tfNonConstExpr
-  elif result.kind == tyStatic:
-    let base = result.skipTypes({tyStatic})
-    if c.inGenericContext > 0 and base.containsGenericType:
-      result = makeTypeFromExpr(c, copyTree(ex))
-      result.flags.incl tfNonConstExpr
-    else:
-      result = base
-  fixupTypeOf(c, prev, result)
 
 proc semTypeIdent(c: PContext, n: PNode): PSym =
   if n.kind == nkSym:
@@ -2176,8 +2100,7 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
     else:
       result = semTypeNode(c, whenResult, prev)
   of nkBracketExpr:
-    # Actually len >= 2 is required, but it doesn't print errors nicely with empty brackets
-    checkMinSonsLen(n, 1, c.config)
+    checkMinSonsLen(n, 2, c.config)
     var head = n[0]
     var s = if head.kind notin nkCallKinds: semTypeIdent(c, head)
             else: symFromExpectedTypeNode(c, semExpr(c, head))
@@ -2195,21 +2118,10 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
         incl result.flags, tfHasAsgn
     of mVarargs: result = semVarargs(c, n, prev)
     of mTypeDesc, mType, mTypeOf:
-      if n.len != 2:
-        let name = case s.magic:
-                   of mTypeDesc: "typedesc"
-                   of mType: "type"
-                   of mTypeOf: "typeof"
-                   else: ""
-        localError(c.config, n.info, errXExpectsOneTypeParam % name)
-      else:
-        result = makeTypeDesc(c, semTypeNode(c, n[1], nil))
-        result.flags.incl tfExplicit
+      result = makeTypeDesc(c, semTypeNode(c, n[1], nil))
+      result.flags.incl tfExplicit
     of mStatic:
-      if n.len != 2:
-        localError(c.config, n.info, errXExpectsOneTypeParam % "static")
-      else:
-        result = semStaticType(c, n[1], prev)
+      result = semStaticType(c, n[1], prev)
     of mExpr:
       result = semTypeNode(c, n[0], nil)
       if result != nil:
@@ -2219,11 +2131,9 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
         for i in 1..<n.len:
           result.rawAddSon(semTypeNode(c, n[i], nil))
     of mDistinct:
-      checkSonsLen(n, 2, c.config)
       result = newOrPrevType(tyDistinct, prev, c)
       addSonSkipIntLit(result, semTypeNode(c, n[1], nil), c.idgen)
     of mVar:
-      checkSonsLen(n, 2, c.config)
       result = newOrPrevType(tyVar, prev, c)
       var base = semTypeNode(c, n[1], nil)
       if base.kind in {tyVar, tyLent}:

compiler/semtypinst.nim

@@ -28,7 +28,7 @@ proc checkConstructedType*(conf: ConfigRef; info: TLineInfo, typ: PType) =
   if t.kind in tyTypeClasses: discard
   elif t.kind in {tyVar, tyLent} and t.elementType.kind in {tyVar, tyLent}:
     localError(conf, info, "type 'var var' is not allowed")
-  elif computeSize(conf, t) == szIllegalRecursion or isRecursiveStructuralType(t):
+  elif computeSize(conf, t) == szIllegalRecursion or isTupleRecursive(t):
     localError(conf, info, "illegal recursion in type '" & typeToString(t) & "'")
 
 proc searchInstTypes*(g: ModuleGraph; key: PType): PType =
@@ -68,8 +68,8 @@ type
   TReplTypeVars* = object
     c*: PContext
     typeMap*: LayeredIdTable  # map PType to PType
-    symMap*: SymMapping       # map PSym to PSym
-    localCache*: TypeMapping  # local cache for remembering already replaced
+    symMap*: SymMapping         # map PSym to PSym
+    localCache*: TypeMapping     # local cache for remembering already replaced
                               # types during instantiation of meta types
                               # (they are not stored in the global cache)
     info*: TLineInfo
@@ -80,7 +80,7 @@ type
     owner*: PSym              # where this instantiation comes from
     recursionLimit: int
 
-proc replaceTypeVarsTAux(cl: var TReplTypeVars, t: PType, isInstValue = false): PType
+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
 
@@ -95,8 +95,8 @@ template checkMetaInvariants(cl: TReplTypeVars, t: PType) = # noop code
       debug t
       writeStackTrace()
 
-proc replaceTypeVarsT*(cl: var TReplTypeVars, t: PType, isInstValue = false): PType =
-  result = replaceTypeVarsTAux(cl, t, isInstValue)
+proc replaceTypeVarsT*(cl: var TReplTypeVars, t: PType): PType =
+  result = replaceTypeVarsTAux(cl, t)
   checkMetaInvariants(cl, result)
 
 proc prepareNode*(cl: var TReplTypeVars, n: PNode): PNode =
@@ -249,24 +249,13 @@ proc hasValuelessStatics(n: PNode): bool =
         a
     proc doThing(_: MyThing)
   ]#
-  result = false
   if n.safeLen == 0 and n.kind != nkEmpty: # Some empty nodes can get in here
-    if n.typ == nil:
-      result = true
-    elif n.typ.kind == tyStatic:
-      result = true
-    elif n.typ.kind == tyTypeDesc:
-      # Check if the base type is an unresolved generic parameter.
-      # This handles cases where a template containing sizeof(T) is called
-      # inside a generic object's when clause - the T needs to be resolved
-      # before we can evaluate the condition.
-      let base = n.typ.skipTypes({tyTypeDesc})
-      if base.kind == tyGenericParam:
-        result = true
+    n.typ == nil or n.typ.kind == tyStatic
   else:
     for x in n:
       if hasValuelessStatics(x):
         return true
+    false
 
 proc replaceTypeVarsN(cl: var TReplTypeVars, n: PNode; start=0; expectedType: PType = nil): PNode =
   if n == nil: return
@@ -287,11 +276,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.skipIntLit(cl.c.idgen)
     # 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
@@ -355,7 +339,7 @@ proc replaceTypeVarsS(cl: var TReplTypeVars, s: PSym, t: PType): PSym =
   #[
 
   We cannot naively check for symbol recursions, because otherwise
-  object types A, B would share their fields!
+  object types A, B whould share their fields!
 
       import tables
 
@@ -492,7 +476,7 @@ proc handleGenericInvocation(cl: var TReplTypeVars, t: PType): PType =
     return
 
   let bbody = last body
-  var newbody = replaceTypeVarsT(cl, bbody, isInstValue = true)
+  var newbody = replaceTypeVarsT(cl, bbody)
   cl.skipTypedesc = oldSkipTypedesc
   newbody.flags = newbody.flags + (t.flags + body.flags - tfInstClearedFlags)
   result.flags = result.flags + newbody.flags - tfInstClearedFlags
@@ -589,7 +573,7 @@ proc propagateFieldFlags(t: PType, n: PNode) =
       propagateFieldFlags(t, son)
   else: discard
 
-proc replaceTypeVarsTAux(cl: var TReplTypeVars, t: PType, isInstValue = false): PType =
+proc replaceTypeVarsTAux(cl: var TReplTypeVars, t: PType): PType =
   template bailout =
     if (t.sym == nil) or (t.sym != nil and sfGeneratedType in t.sym.flags):
       # In the first case 't.sym' can be 'nil' if the type is a ref/ptr, see
@@ -619,13 +603,10 @@ proc replaceTypeVarsTAux(cl: var TReplTypeVars, t: PType, isInstValue = false):
   result = t
   if t == nil: return
 
-  var et = t
-  if t.isConcept:
-    et = t.reduceToBase
   const lookupMetas = {tyStatic, tyGenericParam, tyConcept} + tyTypeClasses - {tyAnything}
-  if et.kind in lookupMetas or
-      (et.kind == tyAnything and tfRetType notin et.flags):
-    let lookup = cl.typeMap.lookup(et)
+  if t.kind in lookupMetas or
+      (t.kind == tyAnything and tfRetType notin t.flags):
+    let lookup = cl.typeMap.lookup(t)
     if lookup != nil: return lookup
 
   case t.kind
@@ -726,17 +707,13 @@ proc replaceTypeVarsTAux(cl: var TReplTypeVars, t: PType, isInstValue = false):
     propagateToOwner(result, result.last)
 
   else:
-    if containsGenericType(t) or
-        # nominal types as direct generic instantiation values
-        # are re-instantiated even if they don't contain generic fields
-        (isInstValue and (t.kind in {tyDistinct, tyObject} or isRefPtrObject(t))):
+    if containsGenericType(t):
       #if not cl.allowMetaTypes:
       bailout()
       result = instCopyType(cl, t)
       result.size = -1 # needs to be recomputed
       #if not cl.allowMetaTypes:
       cl.localCache[t.itemId] = result
-      let propagateInstValue = isInstValue and isRefPtrObject(t)
 
       for i, resulti in result.ikids:
         if resulti != nil:
@@ -746,7 +723,7 @@ proc replaceTypeVarsTAux(cl: var TReplTypeVars, t: PType, isInstValue = false):
               typeToString(result[i], preferDesc) &
               "' inside of type definition: '" &
               t.owner.name.s & "'; Maybe generic arguments are missing?")
-          var r = replaceTypeVarsT(cl, resulti, isInstValue = propagateInstValue)
+          var r = replaceTypeVarsT(cl, resulti)
           if result.kind == tyObject:
             # carefully coded to not skip the precious tyGenericInst:
             let r2 = r.skipTypes({tyAlias, tySink, tyOwned})

compiler/sighashes.nim

@@ -41,7 +41,6 @@ type
     CoType
     CoOwnerSig
     CoIgnoreRange
-    CoIgnoreRangeInArray
     CoConsiderOwned
     CoDistinct
     CoHashTypeInsideNode
@@ -151,7 +150,7 @@ proc hashType(c: var MD5Context, t: PType; flags: set[ConsiderFlag]; conf: Confi
       assert inst.kind == tyGenericInst
       c.hashType inst.genericHead, flags, conf
       for _, a in inst.genericInstParams:
-        c.hashType a, flags+{CoDistinct}, conf
+        c.hashType a, flags, conf
       t.typeInst = inst
       return
     c &= char(t.kind)
@@ -217,17 +216,10 @@ proc hashType(c: var MD5Context, t: PType; flags: set[ConsiderFlag]; conf: Confi
     else:
       for a in t.kids: c.hashType a, flags+{CoIgnoreRange}, conf
   of tyRange:
-    if {CoIgnoreRange, CoIgnoreRangeInArray} * flags == {}:
+    if CoIgnoreRange notin flags:
       c &= char(t.kind)
       c.hashTree(t.n, {}, conf)
-      c.hashType(t.elementType, flags, conf)
-    elif CoIgnoreRangeInArray in flags:
-      # include only the length of the range (not its specific bounds)
-      c &= char(t.kind)
-      let l = lengthOrd(conf, t)
-      lowlevel l
-    else:
-      c.hashType(t.elementType, flags, conf)
+    c.hashType(t.elementType, flags, conf)
   of tyStatic:
     c &= char(t.kind)
     c.hashTree(t.n, {}, conf)
@@ -257,7 +249,7 @@ proc hashType(c: var MD5Context, t: PType; flags: set[ConsiderFlag]; conf: Confi
     if tfVarargs in t.flags: c &= ".varargs"
   of tyArray:
     c &= char(t.kind)
-    c.hashType(t.indexType, flags-{CoIgnoreRange}+{CoIgnoreRangeInArray}, conf)
+    c.hashType(t.indexType, flags-{CoIgnoreRange}, conf)
     c.hashType(t.elementType, flags-{CoIgnoreRange}, conf)
   else:
     c &= char(t.kind)
@@ -442,3 +434,4 @@ proc idOrSig*(s: PSym, currentModule: string,
     if counter != 0:
       result.add "_" & rope(counter+1)
     sigCollisions.inc(sig)
+

compiler/sigmatch.nim

@@ -20,7 +20,6 @@ import std/[intsets, strutils, tables]
 when defined(nimPreviewSlimSystem):
   import std/assertions
 
-
 type
   MismatchKind* = enum
     kUnknown, kAlreadyGiven, kUnknownNamedParam, kTypeMismatch, kVarNeeded,
@@ -86,16 +85,12 @@ 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
     trNoCovariance
     trBindGenericParam  # bind tyGenericParam even with trDontBind
     trIsOutParam
-    trCheckGeneric
 
   TTypeRelFlags* = set[TTypeRelFlag]
 
@@ -104,7 +99,7 @@ const
   isNilConversion = isConvertible # maybe 'isIntConv' fits better?
   maxInheritancePenalty = high(int) div 2
 
-proc markUsed*(c: PContext; info: TLineInfo, s: PSym; checkStyle = true; isGenericInstance = false)
+proc markUsed*(c: PContext; info: TLineInfo, s: PSym; checkStyle = true)
 proc markOwnerModuleAsUsed*(c: PContext; s: PSym)
 
 proc initCandidateAux(ctx: PContext,
@@ -299,9 +294,9 @@ proc checkGeneric(a, b: TCandidate): int =
   var winner = 0
   for aai, bbi in underspecifiedPairs(aa, bb, 1):
     var ma = newCandidate(c, bbi)
-    let tra = typeRel(ma, bbi, aai, {trDontBind, trCheckGeneric})
+    let tra = typeRel(ma, bbi, aai, {trDontBind})
     var mb = newCandidate(c, aai)
-    let trb = typeRel(mb, aai, bbi, {trDontBind, trCheckGeneric})
+    let trb = typeRel(mb, aai, bbi, {trDontBind})
     if tra == isGeneric and trb in {isNone, isInferred, isInferredConvertible}:
       if winner == -1: return 0
       winner = 1
@@ -365,8 +360,6 @@ proc sumGeneric(t: PType): int =
         result += sumGeneric(a)
       break
     else:
-      if t.isConcept:
-        result += t.reduceToBase.conceptBody.len
       break
 
 proc complexDisambiguation(a, b: PType): int =
@@ -599,6 +592,45 @@ proc handleFloatRange(f, a: PType): TTypeRelation =
       else: result = isIntConv
     else: result = isNone
 
+proc reduceToBase(f: PType): PType =
+  #[
+    Returns the lowest order (most general) type that that is compatible with the input.
+    E.g.
+    A[T] = ptr object ... A -> ptr object
+    A[N: static[int]] = array[N, int] ... A -> array
+  ]#
+  case f.kind:
+  of tyGenericParam:
+    if f.len <= 0 or f.skipModifier == nil:
+      result = f
+    else:
+      result = reduceToBase(f.skipModifier)
+  of tyGenericInvocation:
+    result = reduceToBase(f.baseClass)
+  of tyCompositeTypeClass, tyAlias:
+    if not f.hasElementType or f.elementType == nil:
+      result = f
+    else:
+      result = reduceToBase(f.elementType)
+  of tyGenericInst:
+    result = reduceToBase(f.skipModifier)
+  of tyGenericBody:
+    result = reduceToBase(f.typeBodyImpl)
+  of tyUserTypeClass:
+    if f.isResolvedUserTypeClass:
+      result = f.base  # ?? idk if this is right
+    else:
+      result = f.skipModifier
+  of tyStatic, tyOwned, tyVar, tyLent, tySink:
+    result = reduceToBase(f.base)
+  of tyInferred:
+    # This is not true "After a candidate type is selected"
+    result = reduceToBase(f.base)
+  of tyRange:
+    result = f.elementType
+  else:
+    result = f
+
 proc genericParamPut(c: var TCandidate; last, fGenericOrigin: PType) =
   if fGenericOrigin != nil and last.kind == tyGenericInst and
      last.kidsLen-1 == fGenericOrigin.kidsLen:
@@ -607,24 +639,12 @@ proc genericParamPut(c: var TCandidate; last, fGenericOrigin: PType) =
       if x == nil:
         put(c, fGenericOrigin[i], last[i])
 
-proc isGenericObjectOf(f, a: PType): bool =
-  ## checks if `f` is an unparametrized generic type
-  ## that `a` is an instance of
-  if not (f.sym != nil and f.sym.typ.kind == tyGenericBody):
-    # covers the case where `f` is the last child (body) of the `tyGenericBody`
-    return false
-  let aRoot = genericRoot(a)
-  # use sym equality to check if the `tyGenericBody` types are equal
-  result = aRoot != nil and f.sym == aRoot.sym
-
-
-
 proc isObjectSubtype(c: var TCandidate; a, f, fGenericOrigin: PType): int =
   var t = a
   assert t.kind == tyObject
   var depth = 0
   var last = a
-  while t != nil and not (sameObjectTypes(f, t) or isGenericObjectOf(f, t)):
+  while t != nil and not sameObjectTypes(f, t):
     if t.kind != tyObject:  # avoid entering generic params etc
       return -1
     t = t.baseClass
@@ -1144,24 +1164,6 @@ proc isCovariantPtr(c: var TCandidate, f, a: PType): bool =
   else:
     return false
 
-proc enterConceptMatch(c: var TCandidate; f,a: PType, flags: TTypeRelFlags): TTypeRelation =
-  var
-    conceptFlags: set[MatchFlags] = {}
-    container: PType = nil
-    concpt = f
-  if concpt.kind != tyConcept:
-    container = concpt
-    concpt = container.reduceToBase
-  if trDontBind in flags:
-    conceptFlags.incl mfDontBind
-  if trCheckGeneric in flags:
-    conceptFlags.incl mfCheckGeneric
-  let mres = concepts.conceptMatch(c.c, concpt, a, c.bindings, container, flags = conceptFlags)
-  if mres:
-    isGeneric
-  else:
-    isNone
-
 when false:
   proc maxNumericType(prev, candidate: PType): PType =
     let c = candidate.skipTypes({tyRange})
@@ -1236,10 +1238,9 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
     else:
       var candidate = f
 
-      let fType = f.skipTypes({tySink})
-      case fType.kind
+      case f.kind
       of tyGenericParam:
-        var prev = lookup(c.bindings, fType)
+        var prev = lookup(c.bindings, f)
         if prev != nil: candidate = prev
       of tyFromExpr:
         let computedType = tryResolvingStaticExpr(c, f.n).typ
@@ -1449,8 +1450,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
           return isNone
 
       if fRange.rangeHasUnresolvedStatic:
-        if (aRange.kind in {tyGenericParam} and aRange.reduceToBase() == aRange) or
-            (aRange.kind == tyRange and aRange.rangeHasUnresolvedStatic):
+        if aRange.kind in {tyGenericParam} and aRange.reduceToBase() == aRange:
           return
         return inferStaticsInRange(c, fRange, a)
       elif c.c.matchedConcept != nil and aRange.rangeHasUnresolvedStatic:
@@ -1543,14 +1543,12 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
         reduceToBase(a)
     if effectiveArgType.kind == tyObject:
       if sameObjectTypes(f, effectiveArgType):
-        if tfFinal notin f.flags:
-          inc c.inheritancePenalty, ord(c.inheritancePenalty < 0)
+        c.inheritancePenalty = if tfFinal in f.flags: -1 else: 0
         result = isEqual
         # elif tfHasMeta in f.flags: result = recordRel(c, f, a)
       elif trIsOutParam notin flags:
-        let depth = isObjectSubtype(c, effectiveArgType, f, nil)
-        if depth > 0:
-          inc c.inheritancePenalty, depth + ord(c.inheritancePenalty < 0)
+        c.inheritancePenalty = isObjectSubtype(c, effectiveArgType, f, nil)
+        if c.inheritancePenalty > 0:
           result = isSubtype
   of tyDistinct:
     a = a.skipTypes({tyOwned, tyGenericInst, tyRange})
@@ -1570,11 +1568,8 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
             # set['a'..'z'] and set[char] have different representations
             result = isNone
           else:
-            if result >= isConvertible:
-              # but we can convert individual elements of the constructor
-              result = isConvertible
-            else:
-              result = isNone
+            # but we can convert individual elements of the constructor
+            result = isConvertible
   of tyPtr, tyRef:
     a = reduceToBase(a)
     if a.kind == f.kind:
@@ -1673,12 +1668,11 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
 
     let roota = if skipBoth or deptha > depthf: a.skipGenericAlias else: a
     let rootf = if skipBoth or depthf > deptha: f.skipGenericAlias else: f
-    
-    if f.isConcept:
-      result = enterConceptMatch(c, rootf, roota, flags)
-    elif a.kind == tyGenericInst:
+
+    if a.kind == tyGenericInst:
       if roota.base == rootf.base:
         let nextFlags = flags + {trNoCovariance}
+        var hasCovariance = false
         # YYYY
         result = isEqual
 
@@ -1690,7 +1684,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
           if res notin {isEqual, isGeneric}:
             if trNoCovariance notin flags and ff.kind == aa.kind:
               let paramFlags = rootf.base[i-1].flags
-              let hasCovariance =
+              hasCovariance =
                 if tfCovariant in paramFlags:
                   if tfWeakCovariant in paramFlags:
                     isCovariantPtr(c, ff, aa)
@@ -1701,36 +1695,34 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
                     typeRel(c, aa, ff, flags) == isSubtype
               if hasCovariance:
                 continue
-            result = isNone
-            break
 
-        if result != isNone:
-          if prev == nil: put(c, f, a)
+            return isNone
+        if prev == nil: put(c, f, a)
+      else:
+        let fKind = rootf.last.kind
+        if fKind in {tyAnd, tyOr}:
+          result = typeRel(c, last(f), a, flags)
+          if result != isNone: put(c, f, a)
           return
 
-      let fKind = rootf.last.kind
-      if fKind in {tyAnd, tyOr}:
-        result = typeRel(c, last(f), a, flags)
-        if result != isNone: put(c, f, a)
-        return
+        var aAsObject = roota.last
 
-      var aAsObject = roota.last
+        if fKind in {tyRef, tyPtr}:
+          if aAsObject.kind == tyObject:
+            # bug #7600, tyObject cannot be passed
+            # as argument to tyRef/tyPtr
+            return isNone
+          elif aAsObject.kind == fKind:
+            aAsObject = aAsObject.base
 
-      if fKind in {tyRef, tyPtr}:
-        if aAsObject.kind == tyObject:
-          # bug #7600, tyObject cannot be passed
-          # as argument to tyRef/tyPtr
-          return isNone
-        elif aAsObject.kind == fKind:
-          aAsObject = aAsObject.base
-
-      if aAsObject.kind == tyObject and trIsOutParam notin flags:
-        let baseType = aAsObject.base
-        if baseType != nil:
-          if tfFinal notin aAsObject.flags:
+        if aAsObject.kind == tyObject and trIsOutParam notin flags:
+          let baseType = aAsObject.base
+          if baseType != nil:
             inc c.inheritancePenalty, 1 + int(c.inheritancePenalty < 0)
-          let ret = typeRel(c, f, baseType, flags)
-          return if ret in {isEqual,isGeneric}: isSubtype else: ret
+            let ret = typeRel(c, f, baseType, flags)
+            return if ret in {isEqual,isGeneric}: isSubtype else: ret
+
+        result = isNone
     else:
       assert last(origF) != nil
       result = typeRel(c, last(origF), a, flags)
@@ -1747,7 +1739,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
     var x = a.skipGenericAlias
     if x.kind == tyGenericParam and x.len > 0:
       x = x.last
-    let concpt = f.reduceToBase
+    let concpt = f[0].skipTypes({tyGenericBody})
     var preventHack = concpt.kind == tyConcept
     if x.kind == tyOwned and f[0].kind != tyOwned:
       preventHack = true
@@ -1767,10 +1759,6 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
           let tr = typeRel(c, f[i], x[i], flags)
           if tr <= isSubtype: return
         result = isGeneric
-        let impl = last(f[0])
-        if impl.kind == tyObject and tfFinal notin impl.flags:
-          # match non-invocation case
-          inc c.inheritancePenalty, 0 + int(c.inheritancePenalty < 0)
     elif x.kind == tyGenericInst and f[0] == x[0] and
           x.len - 1 == f.len:
       for i in 1..<f.len:
@@ -1780,8 +1768,9 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
           # Workaround for regression #4589
           if f[i].kind != tyTypeDesc: return
       result = isGeneric
-    elif concpt.kind == tyConcept:
-      result = enterConceptMatch(c, f, x, flags)
+    elif x.kind == tyGenericInst and concpt.kind == tyConcept:
+      result = if concepts.conceptMatch(c.c, concpt, x, c.bindings, f): isGeneric
+               else: isNone
     else:
       let genericBody = f[0]
       var askip = skippedNone
@@ -1789,7 +1778,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
       let aobj = x.skipToObject(askip)
       let fobj = genericBody.last.skipToObject(fskip)
       result = typeRel(c, genericBody, x, flags)
-      if result != isNone and concpt.kind != tyConcept:
+      if result != isNone:
         # see tests/generics/tgeneric3.nim for an example that triggers this
         # piece of code:
         #
@@ -1826,8 +1815,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
           depth = -1
 
       if depth >= 0:
-        if aobj.kind == tyObject and tfFinal notin aobj.flags:
-          inc c.inheritancePenalty, depth + int(c.inheritancePenalty < 0)
+        inc c.inheritancePenalty, depth + int(c.inheritancePenalty < 0)
         # bug #4863: We still need to bind generic alias crap, so
         # we cannot return immediately:
         result = if depth == 0: isGeneric else: isSubtype
@@ -1853,10 +1841,9 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
           if  c.inheritancePenalty > -1:
             minInheritance = min(minInheritance, c.inheritancePenalty)
           result = x
-      c.inheritancePenalty = oldInheritancePenalty
       if result >= isIntConv:
         if minInheritance < maxInheritancePenalty:
-          inc c.inheritancePenalty, minInheritance + ord(c.inheritancePenalty < 0)
+          c.inheritancePenalty = oldInheritancePenalty + minInheritance
         if result > isGeneric: result = isGeneric
         bindingRet result
       else:
@@ -1878,12 +1865,9 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
       let target = f.genericHead
       let targetKind = target.kind
       var effectiveArgType = reduceToBase(a)
-      # the skipped child of tyBuiltInTypeClass can be structured differently,
-      # newConstraint constructs them with no children
-      let typeClassArg = effectiveArgType.kind == tyBuiltInTypeClass
       effectiveArgType = effectiveArgType.skipTypes({tyBuiltInTypeClass})
       if targetKind == effectiveArgType.kind:
-        if not typeClassArg and effectiveArgType.isEmptyContainer:
+        if effectiveArgType.isEmptyContainer:
           return isNone
         if targetKind == tyProc:
           if target.flags * {tfIterator} != effectiveArgType.flags * {tfIterator}:
@@ -1918,7 +1902,11 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
         else:
           result = isNone
   of tyConcept:
-    result = enterConceptMatch(c, f, a, flags)
+    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
   of tyCompositeTypeClass:
     considerPreviousT:
       let roota = a.skipGenericAlias
@@ -2190,8 +2178,6 @@ proc implicitConv(kind: TNodeKind, f: PType, arg: PNode, m: TCandidate,
   # keep varness
   if arg.typ != nil and arg.typ.kind == tyVar:
     result.typ() = toVar(result.typ, tyVar, c.idgen)
-    # copy the tfVarIsPtr flag
-    result.typ.flags = arg.typ.flags
   else:
     result.typ() = result.typ.skipTypes({tyVar})
 
@@ -2301,8 +2287,7 @@ proc userConvMatch(c: PContext, m: var TCandidate, f, a: PType,
     # for generic type converters we need to check 'src <- a' before
     # 'f <- dest' in order to not break the unification:
     # see tests/tgenericconverter:
-    var convMatch = newCandidate(c, src)
-    let srca = typeRel(convMatch, src, a)
+    let srca = typeRel(m, src, a)
     if srca notin {isEqual, isGeneric, isSubtype}: continue
 
     # What's done below matches the logic in ``matchesAux``
@@ -2314,7 +2299,7 @@ proc userConvMatch(c: PContext, m: var TCandidate, f, a: PType,
 
     let destIsGeneric = containsGenericType(dest)
     if destIsGeneric:
-      dest = generateTypeInstance(c, convMatch.bindings, arg, dest)
+      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
@@ -2330,8 +2315,7 @@ proc userConvMatch(c: PContext, m: var TCandidate, f, a: PType,
       # it is correct
       var param: PNode = nil
       if srca == isSubtype:
-        # convMatch used here to use its bindings to instantiate subtype:
-        param = implicitConv(nkHiddenSubConv, src, copyTree(arg), convMatch, c)
+        param = implicitConv(nkHiddenSubConv, src, copyTree(arg), m, c)
       elif src.kind in {tyVar}:
         # Analyse the converter return type.
         param = newNodeIT(nkHiddenAddr, arg.info, s.typ.firstParamType)
@@ -2443,6 +2427,7 @@ proc paramTypesMatchAux(m: var TCandidate, f, a: PType,
 
   let oldInheritancePenalty = m.inheritancePenalty
   var r = typeRel(m, f, a)
+
   # This special typing rule for macros and templates is not documented
   # anywhere and breaks symmetry. It's hard to get rid of though, my
   # custom seqs example fails to compile without this:
@@ -2743,7 +2728,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
@@ -2761,17 +2746,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)
@@ -2897,9 +2880,7 @@ 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][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])
@@ -2923,9 +2904,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),
@@ -2939,9 +2918,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:
@@ -2977,9 +2954,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:
@@ -3095,7 +3070,6 @@ proc matches*(c: PContext, n, nOrig: PNode, m: var TCandidate) =
             put(m, formal.typ, defaultValue.typ)
         defaultValue.flags.incl nfDefaultParam
         setSon(m.call, formal.position + 1, defaultValue)
-
   # forget all inferred types if the overload matching failed
   if m.state == csNoMatch:
     for t in m.inferredTypes:

compiler/suggest.nim

@@ -35,7 +35,7 @@
 import prefixmatches, suggestsymdb
 from wordrecg import wDeprecated, wError, wAddr, wYield
 
-import std/[algorithm, sets, parseutils, os]
+import std/[algorithm, sets, parseutils, tables]
 
 when defined(nimsuggest):
   import pathutils # importer
@@ -43,12 +43,6 @@ when defined(nimsuggest):
 const
   sep = '\t'
 
-type 
-  ImportContext = object
-    isMultiImport: bool      # True if we're in a [...] context
-    baseDir: string          # e.g., "folder/" in "import folder/[..."
-    partialModule: string    # The actual module name being typed
-
 #template sectionSuggest(): expr = "##begin\n" & getStackTrace() & "##end\n"
 
 template origModuleName(m: PSym): string = m.name.s
@@ -624,43 +618,41 @@ proc ensureIdx[T](x: var T, y: int) =
 proc ensureSeq[T](x: var seq[T]) =
   if x == nil: newSeq(x, 0)
 
-proc suggestSym*(g: ModuleGraph; info: TLineInfo; s: PSym; usageSym: var PSym; isDecl=true; isGenericInstance=false) {.inline.} =
+proc suggestSym*(g: ModuleGraph; info: TLineInfo; s: PSym; usageSym: var PSym; isDecl=true) {.inline.} =
   ## misnamed: should be 'symDeclared'
   let conf = g.config
   when defined(nimsuggest):
-    if optIdeExceptionInlayHints in conf.globalOptions or not isGenericInstance:
-      g.suggestSymbols.add SymInfoPair(sym: s, info: info, isDecl: isDecl, isGenericInstance: isGenericInstance), optIdeExceptionInlayHints in g.config.globalOptions
+    g.suggestSymbols.add SymInfoPair(sym: s, info: info, isDecl: isDecl), optIdeExceptionInlayHints in g.config.globalOptions
 
-    if not isGenericInstance:
-      if conf.suggestVersion == 0:
-        if s.allUsages.len == 0:
-          s.allUsages = @[info]
-        else:
-          s.addNoDup(info)
+    if conf.suggestVersion == 0:
+      if s.allUsages.len == 0:
+        s.allUsages = @[info]
+      else:
+        s.addNoDup(info)
 
-      if conf.ideCmd == ideUse:
-        findUsages(g, info, s, usageSym)
-      elif conf.ideCmd == ideDef:
-        findDefinition(g, info, s, usageSym)
-      elif conf.ideCmd == ideDus and s != nil:
-        if isTracked(info, conf.m.trackPos, s.name.s.len):
-          suggestResult(conf, symToSuggest(g, s, isLocal=false, ideDef, info, 100, PrefixMatch.None, false, 0))
-        findUsages(g, info, s, usageSym)
-      elif conf.ideCmd == ideHighlight and info.fileIndex == conf.m.trackPos.fileIndex:
-        suggestResult(conf, symToSuggest(g, s, isLocal=false, ideHighlight, info, 100, PrefixMatch.None, false, 0))
-      elif conf.ideCmd == ideOutline and isDecl:
-        # if a module is included then the info we have is inside the include and
-        # we need to walk up the owners until we find the outer most module,
-        # which will be the last skModule prior to an skPackage.
-        var
-          parentFileIndex = info.fileIndex # assume we're in the correct module
-          parentModule = s.owner
-        while parentModule != nil and parentModule.kind == skModule:
-          parentFileIndex = parentModule.info.fileIndex
-          parentModule = parentModule.owner
+    if conf.ideCmd == ideUse:
+      findUsages(g, info, s, usageSym)
+    elif conf.ideCmd == ideDef:
+      findDefinition(g, info, s, usageSym)
+    elif conf.ideCmd == ideDus and s != nil:
+      if isTracked(info, conf.m.trackPos, s.name.s.len):
+        suggestResult(conf, symToSuggest(g, s, isLocal=false, ideDef, info, 100, PrefixMatch.None, false, 0))
+      findUsages(g, info, s, usageSym)
+    elif conf.ideCmd == ideHighlight and info.fileIndex == conf.m.trackPos.fileIndex:
+      suggestResult(conf, symToSuggest(g, s, isLocal=false, ideHighlight, info, 100, PrefixMatch.None, false, 0))
+    elif conf.ideCmd == ideOutline and isDecl:
+      # if a module is included then the info we have is inside the include and
+      # we need to walk up the owners until we find the outer most module,
+      # which will be the last skModule prior to an skPackage.
+      var
+        parentFileIndex = info.fileIndex # assume we're in the correct module
+        parentModule = s.owner
+      while parentModule != nil and parentModule.kind == skModule:
+        parentFileIndex = parentModule.info.fileIndex
+        parentModule = parentModule.owner
 
-        if parentFileIndex == conf.m.trackPos.fileIndex:
-          suggestResult(conf, symToSuggest(g, s, isLocal=false, ideOutline, info, 100, PrefixMatch.None, false, 0))
+      if parentFileIndex == conf.m.trackPos.fileIndex:
+        suggestResult(conf, symToSuggest(g, s, isLocal=false, ideOutline, info, 100, PrefixMatch.None, false, 0))
 
 proc warnAboutDeprecated(conf: ConfigRef; info: TLineInfo; s: PSym) =
   var pragmaNode: PNode
@@ -704,28 +696,26 @@ proc markOwnerModuleAsUsed(c: PContext; s: PSym) =
       else:
         inc i
 
-proc markUsed(c: PContext; info: TLineInfo; s: PSym; checkStyle = true; isGenericInstance = false) =
-  if not isGenericInstance:
-    let conf = c.config
-    incl(s.flags, sfUsed)
-    if s.kind == skEnumField and s.owner != nil:
-      incl(s.owner.flags, sfUsed)
-      if sfDeprecated in s.owner.flags:
+proc markUsed(c: PContext; info: TLineInfo; s: PSym; checkStyle = true) =
+  let conf = c.config
+  incl(s.flags, sfUsed)
+  if s.kind == skEnumField and s.owner != nil:
+    incl(s.owner.flags, sfUsed)
+    if sfDeprecated in s.owner.flags:
+      warnAboutDeprecated(conf, info, s)
+  if {sfDeprecated, sfError} * s.flags != {}:
+    if sfDeprecated in s.flags:
+      if not (c.lastTLineInfo.line == info.line and
+              c.lastTLineInfo.col == info.col):
         warnAboutDeprecated(conf, info, s)
-    if {sfDeprecated, sfError} * s.flags != {}:
-      if sfDeprecated in s.flags:
-        if not (c.lastTLineInfo.line == info.line and
-                c.lastTLineInfo.col == info.col):
-          warnAboutDeprecated(conf, info, s)
-          c.lastTLineInfo = info
+        c.lastTLineInfo = info
 
-      if sfError in s.flags: userError(conf, info, s)
+    if sfError in s.flags: userError(conf, info, s)
   when defined(nimsuggest):
-    suggestSym(c.graph, info, s, c.graph.usageSym, isDecl = false, isGenericInstance = isGenericInstance)
-  if not isGenericInstance:
-    if checkStyle:
-      styleCheckUse(c, info, s)
-    markOwnerModuleAsUsed(c, s)
+    suggestSym(c.graph, info, s, c.graph.usageSym, false)
+  if checkStyle:
+    styleCheckUse(c, info, s)
+  markOwnerModuleAsUsed(c, s)
 
 proc safeSemExpr*(c: PContext, n: PNode): PNode =
   # use only for idetools support!
@@ -756,123 +746,6 @@ proc sugExpr(c: PContext, n: PNode, outputs: var Suggestions) =
     let prefix = if c.config.m.trackPosAttached: nil else: n
     suggestEverything(c, n, prefix, outputs)
 
-proc extractImportContextFromAst(n: PNode, cursorCol: int): ImportContext =
-  result = ImportContext()
-  if n.kind != nkImportStmt: return
-  for child in n:
-    case child.kind
-    of nkIdent:
-      # Single import, e.g. import foo
-      if child.info.col <= cursorCol:
-        result.baseDir = ""
-        result.partialModule = child.ident.s
-        result.isMultiImport = false
-    of nkInfix:
-      # Directory or multi-import, e.g. import std/[os, strutils]
-      if child.len == 3 and child[0].kind == nkIdent and child[0].ident.s == "/":
-        let dir = child[1].ident.s
-        if child[2].kind == nkBracket:
-          result.baseDir = dir
-          result.isMultiImport = true
-          for modNode in child[2]:
-            if modNode.kind == nkIdent and modNode.info.col <= cursorCol:
-              result.partialModule = modNode.ident.s
-        elif child[2].kind == nkIdent:
-          if child[2].info.col <= cursorCol:
-            result.baseDir = dir
-            result.partialModule = child[2].ident.s
-            result.isMultiImport = false
-    else:
-      discard
-
-proc findModuleFile(c: PContext, partialPath: string): seq[string] =
-  result = @[]
-  let currentModuleDir = parentDir(toFullPath(c.config, FileIndex(c.module.position)))
-  
-  proc tryAddModule(path, baseName: string) =
-    if fileExists(path & ".nim"):
-      result.add(baseName)
-
-  proc addModulesFromDir(dir, file: string; result: var seq[string]) =
-    if dirExists(dir):
-      for kind, path in walkDir(dir):
-        if kind in {pcFile, pcDir}:
-          let (_, name, ext) = splitFile(path)
-          if kind == pcFile:
-            if ext == ".nim" and name.startsWith(file):
-              result.add(name) 
-
-  proc collectImportModulesFromDir(dir: string, result: var seq[string]) =
-    for kind, path in walkDir(dir):
-      if kind in {pcFile, pcDir}:
-        let (_, name, ext) = splitFile(path)
-        if kind == pcFile:
-          if ext == ".nim" and name.startsWith(partialPath):
-            result.add(name)
-        else: 
-          if name.startsWith(partialPath):
-            result.add(name)
-    
-  if '/' in partialPath:
-    let parts = partialPath.split('/')
-    let dir = parts[0]
-    let file = parts[1]
-    addModulesFromDir(currentModuleDir / dir, file, result)
-    for searchPath in c.config.searchPaths:
-      let searchDir = searchPath.string / dir
-      addModulesFromDir(searchDir, file, result)
-  else:
-    collectImportModulesFromDir(currentModuleDir, result)
-    for searchPath in c.config.searchPaths:
-      collectImportModulesFromDir(searchPath.string, result)
-
-proc suggestModuleNames(c: PContext, n: PNode) =
-  var suggestions: Suggestions = @[]
-  let partialPath = if n.kind == nkIdent: n.ident.s else: ""
-  proc addModuleSuggestion(path: string) =
-    var suggest = Suggest(
-      section: ideSug,
-      qualifiedPath: @[path],
-      name: addr path,
-      filePath: path,
-      line: n.info.line.int,
-      column: n.info.col.int,
-      doc: "",
-      quality: 100,
-      contextFits: true, 
-      prefix: if partialPath.len > 0: prefixMatch(path, partialPath)
-             else: PrefixMatch.None,
-      symkind: byte skModule
-    )
-    suggestions.add(suggest)
-    
-  let importCtx = extractImportContextFromAst(n, c.config.m.trackPos.col)
-  var searchPath = ""
-  if importCtx.baseDir.len > 0:
-    searchPath = importCtx.baseDir & "/"
-
-  let possibleModules = findModuleFile(c, searchPath & importCtx.partialModule)
-  for moduleName in possibleModules:
-    if moduleName != c.module.name.s:
-      addModuleSuggestion(moduleName)
-
-  produceOutput(suggestions, c.config)
-  suggestQuit()
-
-proc findImportStmtOnLine(n: PNode, line: uint16): PNode =
-  if n.kind in {nkImportStmt, nkFromStmt} and n.info.line == line:
-    return n
-  for i in 0..<n.safeLen:
-    let res = findImportStmtOnLine(n[i], line)
-    if res != nil: return res
-  return nil
-
-template trySuggestModuleNames*(c: PContext, n: PNode) =
-  if c.config.ideCmd == ideSug:
-    let importNode = findImportStmtOnLine(n, c.config.m.trackPos.line)
-    if importNode != nil:
-      suggestModuleNames(c, importNode)
-
 proc suggestExprNoCheck*(c: PContext, n: PNode) =
   # This keeps semExpr() from coming here recursively:
   if c.compilesContextId > 0: return
@@ -901,7 +774,7 @@ proc suggestExprNoCheck*(c: PContext, n: PNode) =
   if outputs.len > 0 and c.config.ideCmd in {ideSug, ideCon, ideDef}:
     produceOutput(outputs, c.config)
     suggestQuit()
- 
+
 proc suggestExpr*(c: PContext, n: PNode) =
   if exactEquals(c.config.m.trackPos, n.info): suggestExprNoCheck(c, n)
 

compiler/suggestsymdb.nim

@@ -16,7 +16,6 @@ type
     caughtExceptions*: seq[PType]
     caughtExceptionsSet*: bool
     isDecl*: bool
-    isGenericInstance*: bool
 
   SuggestFileSymbolDatabase* = object
     lineInfo*: seq[TinyLineInfo]
@@ -24,7 +23,6 @@ type
     caughtExceptions*: seq[seq[PType]]
     caughtExceptionsSet*: PackedBoolArray
     isDecl*: PackedBoolArray
-    isGenericInstance*: PackedBoolArray
     fileIndex*: FileIndex
     trackCaughtExceptions*: bool
     isSorted*: bool
@@ -84,11 +82,6 @@ proc getSymInfoPair*(s: SuggestFileSymbolDatabase; idx: int): SymInfoPair =
         s.caughtExceptionsSet[idx]
       else:
         false,
-    isGenericInstance:
-      if s.trackCaughtExceptions:
-        s.isGenericInstance[idx]
-      else:
-        false,
     isDecl: s.isDecl[idx]
   )
 
@@ -97,7 +90,6 @@ proc reverse*(s: var SuggestFileSymbolDatabase) =
   s.sym.reverse()
   s.caughtExceptions.reverse()
   s.caughtExceptionsSet.reverse()
-  s.isGenericInstance.reverse()
   s.isDecl.reverse()
 
 proc newSuggestFileSymbolDatabase*(aFileIndex: FileIndex; aTrackCaughtExceptions: bool): SuggestFileSymbolDatabase =
@@ -107,7 +99,6 @@ proc newSuggestFileSymbolDatabase*(aFileIndex: FileIndex; aTrackCaughtExceptions
     caughtExceptions: @[],
     caughtExceptionsSet: newPackedBoolArray(),
     isDecl: newPackedBoolArray(),
-    isGenericInstance: newPackedBoolArray(),
     fileIndex: aFileIndex,
     trackCaughtExceptions: aTrackCaughtExceptions,
     isSorted: true
@@ -128,8 +119,6 @@ func compare*(s: var SuggestFileSymbolDatabase; i, j: int): int =
   result = cmp(s.lineInfo[i], s.lineInfo[j])
   if result == 0:
     result = cmp(s.isDecl[i], s.isDecl[j])
-  if result == 0 and s.trackCaughtExceptions:
-    result = cmp(s.isGenericInstance[i], s.isGenericInstance[j])
 
 proc exchange(s: var SuggestFileSymbolDatabase; i, j: int) =
   if i == j:
@@ -144,9 +133,6 @@ proc exchange(s: var SuggestFileSymbolDatabase; i, j: int) =
     var tmp3 = s.caughtExceptionsSet[i]
     s.caughtExceptionsSet[i] = s.caughtExceptionsSet[j]
     s.caughtExceptionsSet[j] = tmp3
-    var tmp6 = s.isGenericInstance[i]
-    s.isGenericInstance[i] = s.isGenericInstance[j]
-    s.isGenericInstance[j] = tmp6
   var tmp4 = s.isDecl[i]
   s.isDecl[i] = s.isDecl[j]
   s.isDecl[j] = tmp4
@@ -210,17 +196,12 @@ proc add*(s: var SuggestFileSymbolDatabase; v: SymInfoPair) =
   if s.trackCaughtExceptions:
     s.caughtExceptions.add(v.caughtExceptions)
     s.caughtExceptionsSet.add(v.caughtExceptionsSet)
-    s.isGenericInstance.add(v.isGenericInstance)
   s.isSorted = false
 
 proc add*(s: var SuggestSymbolDatabase; v: SymInfoPair; trackCaughtExceptions: bool) =
   s.mgetOrPut(v.info.fileIndex, newSuggestFileSymbolDatabase(v.info.fileIndex, trackCaughtExceptions)).add(v)
 
-proc findSymInfoIndex*(s: var SuggestFileSymbolDatabase; li: TLineInfo; isGenericInstance: bool): int =
-  # if trackCaughtExceptions is false, then all records in the database are not generic instances, so
-  # if we're searching for a generic instance, we find none
-  if isGenericInstance and not s.trackCaughtExceptions:
-    return -1
+proc findSymInfoIndex*(s: var SuggestFileSymbolDatabase; li: TLineInfo): int =
   doAssert(li.fileIndex == s.fileIndex)
   if not s.isSorted:
     s.sort()
@@ -229,17 +210,3 @@ proc findSymInfoIndex*(s: var SuggestFileSymbolDatabase; li: TLineInfo; isGeneri
     col: li.col
   )
   result = binarySearch(s.lineInfo, q, cmp)
-  # if trackCaughtExceptions is false, then all records in the database are not generic instances, so
-  # if we're a searching for a non-generic instance, then we're done, we return what we have found
-  if not isGenericInstance and not s.trackCaughtExceptions:
-    return
-  # in this case trackCaughtExceptions is true, and the database contains both generic and non-generic instances, so we need
-  # to check the isGenericInstance flag also
-  if result != -1:
-    # search through a sequence of equal lineInfos to find a matching isGenericInstance
-    while result > 0 and s.isGenericInstance[result] != isGenericInstance and cmp(s.lineInfo[result], s.lineInfo[result - 1]) == 0:
-      dec result
-    while result < (s.lineInfo.len - 1) and s.isGenericInstance[result] != isGenericInstance and cmp(s.lineInfo[result], s.lineInfo[result + 1]) == 0:
-      inc result
-    if s.isGenericInstance[result] != isGenericInstance:
-      result = -1

compiler/transf.nim

@@ -40,7 +40,7 @@ import closureiters, lambdalifting
 
 type
   PTransCon = ref object # part of TContext; stackable
-    mapping: TIdTable[PNode]  # mapping from symbols to nodes
+    mapping: Table[ItemId, PNode]     # mapping from symbols to nodes
     owner: PSym               # current owner
     forStmt: PNode            # current for stmt
     forLoopBody: PNode   # transformed for loop body
@@ -78,7 +78,7 @@ proc newTransNode(kind: TNodeKind, n: PNode,
 
 proc newTransCon(owner: PSym): PTransCon =
   assert owner != nil
-  result = PTransCon(mapping: initIdTable[PNode](), owner: owner)
+  result = PTransCon(mapping: initTable[ItemId, PNode](), owner: owner)
 
 proc pushTransCon(c: PTransf, t: PTransCon) =
   t.next = c.transCon
@@ -106,13 +106,6 @@ proc transformSons(c: PTransf, n: PNode, noConstFold = false): PNode =
   for i in 0..<n.len:
     result[i] = transform(c, n[i], noConstFold)
 
-proc transformSonsAfterType(c: PTransf, n: PNode, noConstFold = false): PNode =
-  result = newTransNode(n)
-  assert n.len != 0
-  result[0] = copyTree(n[0])
-  for i in 1..<n.len:
-    result[i] = transform(c, n[i], noConstFold)
-
 proc newAsgnStmt(c: PTransf, kind: TNodeKind, le: PNode, ri: PNode; isFirstWrite: bool): PNode =
   result = newTransNode(kind, ri.info, 2)
   result[0] = le
@@ -259,8 +252,7 @@ proc transformBlock(c: PTransf, n: PNode): PNode =
   var labl: PSym
   if c.inlining > 0:
     labl = newLabel(c, n[0])
-    if n[0].kind != nkEmpty:
-      c.transCon.mapping[n[0].sym.itemId] = newSymNode(labl)
+    c.transCon.mapping[n[0].sym.itemId] = newSymNode(labl)
   else:
     labl =
       if n[0].kind != nkEmpty:
@@ -329,7 +321,7 @@ proc introduceNewLocalVars(c: PTransf, n: PNode): PNode =
     if a.kind == nkSym:
       n[1] = transformSymAux(c, a)
     return n
-  of nkProcDef, nkFuncDef, nkMethodDef, nkConverterDef: # todo optimize nosideeffects?
+  of nkProcDef: # todo optimize nosideeffects?
     result = newTransNode(n)
     let x = newSymNode(copySym(n[namePos].sym, c.idgen))
     c.transCon.mapping[n[namePos].sym.itemId] = x
@@ -374,19 +366,6 @@ proc transformAsgn(c: PTransf, n: PNode): PNode =
   result[0] = letSection
   result[1] = asgnNode
 
-template assignTupleUnpacking(c: PTransf, e: PNode) =
-  for i in 0..<c.transCon.forStmt.len - 2:
-    if c.transCon.forStmt[i].kind == nkVarTuple:
-      for j in 0..<c.transCon.forStmt[i].len-1:
-        let lhs = c.transCon.forStmt[i][j]
-        let rhs = transform(c, newTupleAccess(c.graph, newTupleAccess(c.graph, e, i), j))
-        result.add(asgnTo(lhs, rhs))
-    else:
-      let lhs = c.transCon.forStmt[i]
-      let rhs = transform(c, newTupleAccess(c.graph, e, i))
-      result.add(asgnTo(lhs, rhs))
-
-
 proc transformYield(c: PTransf, n: PNode): PNode =
   proc asgnTo(lhs: PNode, rhs: PNode): PNode =
     # Choose the right assignment instruction according to the given ``lhs``
@@ -421,8 +400,7 @@ proc transformYield(c: PTransf, n: PNode): PNode =
           let lhs = c.transCon.forStmt[i]
           let rhs = transform(c, v)
           result.add(asgnTo(lhs, rhs))
-    elif e.kind notin {nkAddr, nkHiddenAddr} and e.kind != nkSym:
-      # no need to generate temp for address operation + nodes without sideeffects
+    elif e.kind notin {nkAddr, nkHiddenAddr}: # no need to generate temp for address operation
       # TODO do not use temp for nodes which cannot have side-effects
       var tmp = newTemp(c, e.typ, e.info)
       let v = newNodeI(nkVarSection, e.info)
@@ -430,9 +408,21 @@ proc transformYield(c: PTransf, n: PNode): PNode =
 
       result.add transform(c, v)
 
-      assignTupleUnpacking(c, tmp)
+      for i in 0..<c.transCon.forStmt.len - 2:
+        if c.transCon.forStmt[i].kind == nkVarTuple:
+          for j in 0..<c.transCon.forStmt[i].len-1:
+            let lhs = c.transCon.forStmt[i][j]
+            let rhs = transform(c, newTupleAccess(c.graph, newTupleAccess(c.graph, tmp, i), j))
+            result.add(asgnTo(lhs, rhs))
+        else:
+          let lhs = c.transCon.forStmt[i]
+          let rhs = transform(c, newTupleAccess(c.graph, tmp, i))
+          result.add(asgnTo(lhs, rhs))
     else:
-      assignTupleUnpacking(c, e)
+      for i in 0..<c.transCon.forStmt.len - 2:
+        let lhs = c.transCon.forStmt[i]
+        let rhs = transform(c, newTupleAccess(c.graph, e, i))
+        result.add(asgnTo(lhs, rhs))
   else:
     if c.transCon.forStmt[0].kind == nkVarTuple:
       var notLiteralTuple = false # we don't generate temp for tuples with const value: (1, 2, 3)
@@ -445,8 +435,7 @@ proc transformYield(c: PTransf, n: PNode): PNode =
       else:
         notLiteralTuple = true
 
-      if e.kind notin {nkAddr, nkHiddenAddr} and notLiteralTuple and e.kind != nkSym:
-        # no need to generate temp for address operation + nodes without sideeffects
+      if e.kind notin {nkAddr, nkHiddenAddr} and notLiteralTuple:
         # TODO do not use temp for nodes which cannot have side-effects
         var tmp = newTemp(c, e.typ, e.info)
         let v = newNodeI(nkVarSection, e.info)
@@ -518,8 +507,7 @@ 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)
+          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
@@ -552,34 +540,7 @@ proc transformConv(c: PTransf, n: PNode): PNode =
     # we don't include uint and uint64 here as these are no ordinal types ;-)
     if not isOrdinalType(source):
       # float -> int conversions. ugh.
-      # generate a range check:
-      if dest.kind in tyInt..tyInt64:
-        if dest.kind == tyInt64 or source.kind == tyInt64:
-          result = newTransNode(nkChckRange64, n, 3)
-        else:
-          result = newTransNode(nkChckRange, n, 3)
-        dest = skipTypes(n.typ, abstractVar)
-
-        if dest.size < source.size:
-          let intType =
-            if source.size == 4:
-              getSysType(c.graph, n.info, tyInt32)
-            else:
-              getSysType(c.graph, n.info, tyInt64)
-          result[0] = 
-            newTreeIT(n.kind, n.info, n.typ, n[0],
-              newTreeIT(nkConv, n.info, intType,
-              newNodeIT(nkType, n.info, intType), transform(c, n[1]))
-            )
-
-        else:
-          result[0] = transformSons(c, n)
-
-        result[1] = newIntTypeNode(firstOrd(c.graph.config, dest), dest)
-        result[2] = newIntTypeNode(lastOrd(c.graph.config, dest), dest)
-      else:
-        result = transformSons(c, n)
-
+      result = transformSons(c, n)
     elif firstOrd(c.graph.config, n.typ) <= firstOrd(c.graph.config, n[1].typ) and
         lastOrd(c.graph.config, n[1].typ) <= lastOrd(c.graph.config, n.typ):
       # BUGFIX: simply leave n as it is; we need a nkConv node,
@@ -676,12 +637,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:
@@ -827,25 +782,12 @@ proc transformFor(c: PTransf, n: PNode): PNode =
         t = formal.ast.typ # better use the type that actually has a destructor.
       elif t.destructor == nil and arg.typ.destructor != nil:
         t = arg.typ
-
-      if arg.kind in {nkDerefExpr, nkHiddenDeref} and
-          arg[0].typ.skipTypes(abstractInst).kind != tyLent:
-        # optimizes for `[]` # bug #24093
-        # bug #25251: enforce a copy if the arg is a deref of a lent pointer
-        # since the arg could be a temporary that will go out of scope
-        var temp = newTemp(c, arg[0].typ, formal.info)
-        addVar(v, temp)
-        stmtList.add(newAsgnStmt(c, nkFastAsgn, temp, arg[0], true))
-        let newD = newDeref(temp)
-        newD.typ() = t
-        newC.mapping[formal.itemId] = newD
-      else:
-        # generate a temporary and produce an assignment statement:
-        var temp = newTemp(c, t, formal.info)
-        #incl(temp.sym.flags, sfCursor)
-        addVar(v, temp)
-        stmtList.add(newAsgnStmt(c, nkFastAsgn, temp, arg, true))
-        newC.mapping[formal.itemId] = temp
+      # generate a temporary and produce an assignment statement:
+      var temp = newTemp(c, t, formal.info)
+      #incl(temp.sym.flags, sfCursor)
+      addVar(v, temp)
+      stmtList.add(newAsgnStmt(c, nkFastAsgn, temp, arg, true))
+      newC.mapping[formal.itemId] = temp
     of paVarAsgn:
       assert(skipTypes(formal.typ, abstractInst).kind in {tyVar, tyLent})
       newC.mapping[formal.itemId] = arg
@@ -861,7 +803,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))
@@ -915,18 +857,9 @@ proc transformArrayAccess(c: PTransf, n: PNode): PNode =
   if n[0].kind == nkSym and n[0].sym.kind == skType:
     result = n
   else:
-    result = transformSons(c, n)
-    if n.len >= 2 and result[1].kind in {nkChckRange, nkChckRange64} and
-        n[1].kind in {nkHiddenStdConv, nkHiddenSubConv}:
-      # implicit conversion, was transformed into range check
-      # remove in favor of index check if conversion to array index type
-      # has to be done here because the array index type needs to be relaxed
-      # i.e. a uint32 index can implicitly convert to range[0..3] but not int
-      let arr = skipTypes(n[0].typ, abstractVarRange)
-      if arr.kind == tyArray and
-          firstOrd(c.graph.config, arr) == getOrdValue(result[1][1]) and
-          lastOrd(c.graph.config, arr) == getOrdValue(result[1][2]):
-        result[1] = result[1].skipConv
+    result = newTransNode(n)
+    for i in 0..<n.len:
+      result[i] = transform(c, skipConv(n[i]))
 
 proc getMergeOp(n: PNode): PSym =
   case n.kind
@@ -997,23 +930,6 @@ proc transformCall(c: PTransf, n: PNode): PNode =
     else:
       result = s
 
-proc transformBareExcept(c: PTransf, n: PNode): PNode =
-  result = newTransNode(nkExceptBranch, n, 1)
-  if isEmptyType(n[0].typ):
-    result[0] = newNodeI(nkStmtList, n[0].info)
-  else:
-    result[0] = newNodeIT(nkStmtListExpr, n[0].info, n[0].typ)
-  # Generating `raiseDefect()`
-  let raiseDefectCall = callCodegenProc(c.graph, "raiseDefect", n[0].info)
-  result[0].add raiseDefectCall
-  if n[0].kind in {nkStmtList, nkStmtListExpr}:
-    # flattens stmtList
-    for son in n[0]:
-      result[0].add son
-  else:
-    result[0].add n[0]
-  result[0] = transform(c, result[0])
-
 proc transformExceptBranch(c: PTransf, n: PNode): PNode =
   if n[0].isInfixAs() and not isImportedException(n[0][1].typ, c.graph.config):
     let excTypeNode = n[0][1]
@@ -1042,9 +958,6 @@ proc transformExceptBranch(c: PTransf, n: PNode): PNode =
     # Replace the `Exception as foobar` with just `Exception`.
     result[0] = transform(c, n[0][1])
     result[1] = actions
-  elif n.len == 1 and
-      noPanicOnExcept notin c.graph.config.legacyFeatures:
-    result = transformBareExcept(c, n)
   else:
     result = transformSons(c, n)
 
@@ -1156,7 +1069,9 @@ proc transform(c: PTransf, n: PNode, noConstFold = false): PNode =
   of nkBreakStmt: result = transformBreak(c, n)
   of nkCallKinds:
     result = transformCall(c, n)
-  of nkAddr, nkHiddenAddr:
+  of nkHiddenAddr:
+    result = transformAddrDeref(c, n, {nkHiddenDeref}, isAddr = true)
+  of nkAddr:
     result = transformAddrDeref(c, n, {nkDerefExpr, nkHiddenDeref}, isAddr = true)
   of nkDerefExpr:
     result = transformAddrDeref(c, n, {nkAddr, nkHiddenAddr})
@@ -1169,9 +1084,6 @@ proc transform(c: PTransf, n: PNode, noConstFold = false): PNode =
       result = transformAddrDeref(c, n, {nkAddr, nkHiddenAddr})
   of nkHiddenStdConv, nkHiddenSubConv, nkConv:
     result = transformConv(c, n)
-  of nkObjConstr, nkCast:
-    # don't try to transform type node
-    result = transformSonsAfterType(c, n)
   of nkDiscardStmt:
     result = n
     if n[0].kind != nkEmpty:

compiler/trees.nim

@@ -131,8 +131,8 @@ proc isRange*(n: PNode): bool {.inline.} =
     let callee = n[0]
     if (callee.kind == nkIdent and callee.ident.id == ord(wDotDot)) or
        (callee.kind == nkSym and callee.sym.name.id == ord(wDotDot)) or
-       (callee.kind in {nkClosedSymChoice, nkOpenSymChoice, nkOpenSym} and
-        callee[0].sym.name.id == ord(wDotDot)):
+       (callee.kind in {nkClosedSymChoice, nkOpenSymChoice} and
+        callee[1].sym.name.id == ord(wDotDot)):
       result = true
     else:
       result = false
@@ -145,7 +145,7 @@ proc whichPragma*(n: PNode): TSpecialWord =
   of nkIdent: result = whichKeyword(key.ident)
   of nkSym: result = whichKeyword(key.sym.name)
   of nkCast: return wCast
-  of nkClosedSymChoice, nkOpenSymChoice, nkOpenSym:
+  of nkClosedSymChoice, nkOpenSymChoice:
     return whichPragma(key[0])
   of nkBracketExpr:
     if n.kind notin nkPragmaCallKinds: return wInvalid

compiler/treetab.nim

@@ -21,13 +21,20 @@ proc hashTree*(n: PNode): Hash =
     return
   result = ord(n.kind)
   case n.kind
-  of nkEmpty: discard
-  of nkSym: result = result !& n.sym.id
-  of nkIdent: result = result !& n.ident.h
-  of nkCharLit..nkUInt64Lit: result = result !& hash(n.intVal)
-  of nkFloatLit..nkFloat64Lit: result = result !& hash(cast[uint64](n.floatVal))
-  of nkStrLit..nkTripleStrLit: result = result !& hash(n.strVal)
-  of nkType, nkNilLit: result = result !& hash(n.typ.itemId)
+  of nkEmpty, nkNilLit, nkType:
+    discard
+  of nkIdent:
+    result = result !& n.ident.h
+  of nkSym:
+    result = result !& n.sym.id
+  of nkCharLit..nkUInt64Lit:
+    if (n.intVal >= low(int)) and (n.intVal <= high(int)):
+      result = result !& int(n.intVal)
+  of nkFloatLit..nkFloat64Lit:
+    if (n.floatVal >= - 1000000.0) and (n.floatVal <= 1000000.0):
+      result = result !& toInt(n.floatVal)
+  of nkStrLit..nkTripleStrLit:
+    result = result !& hash(n.strVal)
   else:
     for i in 0..<n.len:
       result = result !& hashTree(n[i])
@@ -35,36 +42,32 @@ proc hashTree*(n: PNode): Hash =
   #echo "hashTree ", result
   #echo n
 
-proc treesEquivalent(a, b: PNode; ignoreTypes: bool): bool =
+proc treesEquivalent(a, b: PNode): bool =
   if a == b:
     result = true
   elif (a != nil) and (b != nil) and (a.kind == b.kind):
     case a.kind
-    of nkEmpty: result = true
+    of nkEmpty, nkNilLit, nkType: result = true
     of nkSym: result = a.sym.id == b.sym.id
     of nkIdent: result = a.ident.id == b.ident.id
     of nkCharLit..nkUInt64Lit: result = a.intVal == b.intVal
-    of nkFloatLit..nkFloat64Lit:
-      result = cast[uint64](a.floatVal) == cast[uint64](b.floatVal)
+    of nkFloatLit..nkFloat64Lit: result = a.floatVal == b.floatVal
     of nkStrLit..nkTripleStrLit: result = a.strVal == b.strVal
-    of nkType, nkNilLit:
-      result = a.typ == b.typ
     else:
       if a.len == b.len:
         for i in 0..<a.len:
-          if not treesEquivalent(a[i], b[i], ignoreTypes): return
+          if not treesEquivalent(a[i], b[i]): return
         result = true
       else:
         result = false
-    if result and not ignoreTypes:
-      result = sameTypeOrNil(a.typ, b.typ)
+    if result: result = sameTypeOrNil(a.typ, b.typ)
   else:
     result = false
 
 proc nodeTableRawGet(t: TNodeTable, k: Hash, key: PNode): int =
   var h: Hash = k and high(t.data)
   while t.data[h].key != nil:
-    if (t.data[h].h == k) and treesEquivalent(t.data[h].key, key, t.ignoreTypes):
+    if (t.data[h].h == k) and treesEquivalent(t.data[h].key, key):
       return h
     h = nextTry(h, high(t.data))
   result = -1

compiler/typeallowed.nim

@@ -18,8 +18,7 @@ when defined(nimPreviewSlimSystem):
 
 type
   TTypeAllowedFlag* = enum
-    taTupField, # field of a tuple
-    taObjField, # field of an object
+    taField,
     taHeap,
     taConcept,
     taIsOpenArray,
@@ -70,8 +69,8 @@ proc typeAllowedAux(marker: var IntSet, typ: PType, kind: TSymKind,
       result = t
     elif taIsOpenArray in flags:
       result = t
-    elif t.kind == tyLent and (((kind != skResult or taObjField in flags) and views notin c.features) or
-      (kind == skParam and {taIsCastable, taObjField, taTupField} * flags == {})): # lent cannot be used as parameters.
+    elif t.kind == tyLent and ((kind != skResult and views notin c.features) or
+      (kind == skParam and {taIsCastable, taField} * flags == {})): # lent cannot be used as parameters.
                                                        # except in the cast environment and as the field of an object
       result = t
     elif isOutParam(t) and kind != skParam:
@@ -188,12 +187,12 @@ proc typeAllowedAux(marker: var IntSet, typ: PType, kind: TSymKind,
         t.baseClass != nil and taIsDefaultField notin flags:
       result = t
     else:
-      let flags = flags+{taObjField, taVoid}
+      let flags = flags+{taField, taVoid}
       result = typeAllowedAux(marker, t.baseClass, kind, c, flags)
       if result.isNil and t.n != nil:
         result = typeAllowedNode(marker, t.n, kind, c, flags)
   of tyTuple:
-    let flags = flags+{taTupField, taVoid}
+    let flags = flags+{taField, taVoid}
     for a in t.kids:
       result = typeAllowedAux(marker, a, kind, c, flags)
       if result != nil: break
@@ -210,6 +209,9 @@ proc typeAllowedAux(marker: var IntSet, typ: PType, kind: TSymKind,
       result = typeAllowedAux(marker, t.skipModifier, kind, c, flags+{taHeap})
     else:
       result = t
+  of tyConcept:
+    if kind != skParam: result = t
+    else: result = nil
 
 proc typeAllowed*(t: PType, kind: TSymKind; c: PContext; flags: TTypeAllowedFlags = {}): PType =
   # returns 'nil' on success and otherwise the part of the type that is

compiler/types.nim

@@ -102,9 +102,6 @@ const
   # typedescX is used if we're sure tyTypeDesc should be included (or skipped)
   typedescPtrs* = abstractPtrs + {tyTypeDesc}
   typedescInst* = abstractInst + {tyTypeDesc, tyOwned, tyUserTypeClass}
-  
-  # incorrect definition of `[]` and `[]=` for these types in system.nim
-  arrPutGetMagicApplies* = {tyArray, tyOpenArray, tyString, tySequence, tyCstring, tyTuple}
 
 proc invalidGenericInst*(f: PType): bool =
   result = f.kind == tyGenericInst and skipModifier(f) == nil
@@ -165,7 +162,7 @@ proc isFloatLit*(t: PType): bool {.inline.} =
 
 proc addTypeHeader*(result: var string, conf: ConfigRef; typ: PType; prefer: TPreferedDesc = preferMixed; getDeclarationPath = true) =
   result.add typeToString(typ, prefer)
-  if getDeclarationPath and typ.sym != nil: result.addDeclaredLoc(conf, typ.sym)
+  if getDeclarationPath: result.addDeclaredLoc(conf, typ.sym)
 
 proc getProcHeader*(conf: ConfigRef; sym: PSym; prefer: TPreferedDesc = preferName; getDeclarationPath = true): string =
   assert sym != nil
@@ -766,7 +763,7 @@ proc typeToString(typ: PType, prefer: TPreferedDesc = preferName): string =
         prag.add("effectsOf: ")
         prag.add(effectsOfStr)
       if not hasImplicitRaises and prefer == preferInferredEffects and not isNil(t.owner) and not isNil(t.owner.typ) and not isNil(t.owner.typ.n) and (t.owner.typ.n.len > 0):
-        let effects = t.n[0]
+        let effects = t.owner.typ.n[0]
         if effects.kind == nkEffectList and effects.len == effectListLen:
           var inferredRaisesStr = ""
           let effs = effects[exceptionEffects]
@@ -1204,19 +1201,17 @@ proc sameChildrenAux(a, b: PType, c: var TSameTypeClosure): bool =
     if not result: return
 
 proc isGenericAlias*(t: PType): bool =
-  return t.kind == tyGenericInst and t.skipModifier.skipTypes({tyAlias}).kind == tyGenericInst
+  return t.kind == tyGenericInst and t.skipModifier.kind == tyGenericInst
 
 proc genericAliasDepth*(t: PType): int =
   result = 0
-  var it = t.skipTypes({tyAlias})
+  var it = t
   while it.isGenericAlias:
-    it = it.skipModifier.skipTypes({tyAlias})
+    it = it.skipModifier
     inc result
 
 proc skipGenericAlias*(t: PType): PType =
-  result = t.skipTypes({tyAlias})
-  if result.isGenericAlias:
-    result = result.skipModifier.skipTypes({tyAlias})
+  return if t.isGenericAlias: t.skipModifier else: t
 
 proc sameFlags*(a, b: PType): bool {.inline.} =
   result = eqTypeFlags*a.flags == eqTypeFlags*b.flags
@@ -1309,34 +1304,16 @@ proc sameTypeAux(x, y: PType, c: var TSameTypeClosure): bool =
       cycleCheck()
       result = sameTypeAux(a.skipModifier, b.skipModifier, c)
   of tyObject:
-    result = sameFlags(a, b)
-    if result:
+    withoutShallowFlags:
       ifFastObjectTypeCheckFailed(a, b):
         cycleCheck()
-        # should be generic, and belong to the same generic head type:
-        assert a.typeInst != nil, "generic object " & $a & " has no typeInst"
-        assert b.typeInst != nil, "generic object " & $b & " has no typeInst"
-        if result:
-          withoutShallowFlags:
-            # this is required because of generic `ref object`s,
-            # the value of their dereferences are not wrapped in `tyGenericInst`,
-            # so we need to check the generic parameters here
-            for ff, aa in underspecifiedPairs(a.typeInst, b.typeInst, 1, -1):
-              if not sameTypeAux(ff, aa, c): return false
+        result = sameObjectStructures(a, b, c) and sameFlags(a, b)
   of tyDistinct:
     cycleCheck()
     if c.cmp == dcEq:
-      result = sameFlags(a, b)
-      if result:
+      if sameFlags(a, b):
         ifFastObjectTypeCheckFailed(a, b):
-          # should be generic, and belong to the same generic head type:
-          assert a.typeInst != nil, "generic distinct type " & $a & " has no typeInst"
-          assert b.typeInst != nil, "generic distinct type " & $b & " has no typeInst"
-          withoutShallowFlags:
-            # just in case `tyGenericInst` was skipped at some point,
-            # we need to check the generic parameters here
-            for ff, aa in underspecifiedPairs(a.typeInst, b.typeInst, 1, -1):
-              if not sameTypeAux(ff, aa, c): return false
+          result = sameTypeAux(a.elementType, b.elementType, c)
     else:
       result = sameTypeAux(a.elementType, b.elementType, c) and sameFlags(a, b)
   of tyEnum, tyForward:
@@ -1420,7 +1397,7 @@ proc sameBackendTypeIgnoreRange*(x, y: PType): bool =
 
 proc sameBackendTypePickyAliases*(x, y: PType): bool =
   var c = initSameTypeClosure()
-  c.flags.incl {IgnoreTupleFields, IgnoreRangeShallow, PickyCAliases, PickyBackendAliases}
+  c.flags.incl {IgnoreTupleFields, PickyCAliases, PickyBackendAliases}
   c.cmp = dcEqIgnoreDistinct
   result = sameTypeAux(x, y, c)
 
@@ -1485,17 +1462,8 @@ proc commonSuperclass*(a, b: PType): PType =
     y = y.baseClass
 
 proc lacksMTypeField*(typ: PType): bool {.inline.} =
-  ## Returns true if the type is an object that lacks a m_type field.
-  ## It doesn't check base classes.
   (typ.sym != nil and sfPure in typ.sym.flags) or tfFinal in typ.flags
 
-proc isObjLackingTypeField*(typ: PType): bool {.inline.} =
-  ## Returns true if the type is an object that lacks a type field.
-  ## Object types that store type headers are not final or pure and
-  ## have inheritable root types, which are not pure, neither.
-  result = (typ.kind == tyObject) and ((tfFinal in typ.flags) and
-      (typ.baseClass == nil) or isPureObject(typ))
-
 include sizealignoffsetimpl
 
 proc computeSize*(conf: ConfigRef; typ: PType): BiggestInt =
@@ -1515,31 +1483,6 @@ proc getSize*(conf: ConfigRef; typ: PType): BiggestInt =
   computeSizeAlign(conf, typ)
   result = typ.size
 
-proc setImportedTypeSize*(conf: ConfigRef, t: PType, size: int) =
-  t.size = size
-  if tfPacked in t.flags or size <= 1:
-    t.align = 1
-  elif size <= 2:
-    t.align = 2
-  elif size <= 4:
-    t.align = 4
-  else:
-    t.align = floatInt64Align(conf)
-
-proc isConcept*(t: PType): bool=
-  case t.kind
-  of tyConcept: true
-  of tyCompositeTypeClass:
-    t.hasElementType and isConcept(t.elementType)
-  of tyGenericBody:
-    t.typeBodyImpl.kind == tyConcept
-  of tyGenericInvocation, tyGenericInst:
-    if t.baseClass.kind == tyGenericBody:
-      t.baseClass.typeBodyImpl.kind == tyConcept
-    else:
-      t.baseClass.kind == tyConcept
-  else: false
-
 proc containsGenericTypeIter(t: PType, closure: RootRef): bool =
   case t.kind
   of tyStatic:
@@ -1550,8 +1493,6 @@ proc containsGenericTypeIter(t: PType, closure: RootRef): bool =
     return false
   of GenericTypes + tyTypeClasses + {tyFromExpr}:
     return true
-  of tyGenericInst:
-    return t.isConcept
   else:
     return false
 
@@ -1897,7 +1838,7 @@ proc typeMismatch*(conf: ConfigRef; info: TLineInfo, formal, actual: PType, n: P
       processPragmaAndCallConvMismatch(msg, a, b, conf)
     localError(conf, info, msg)
 
-proc isRecursiveStructuralType(t: PType, cycleDetector: var IntSet): bool =
+proc isTupleRecursive(t: PType, cycleDetector: var IntSet): bool =
   if t == nil:
     return false
   if cycleDetector.containsOrIncl(t.id):
@@ -1908,30 +1849,19 @@ proc isRecursiveStructuralType(t: PType, cycleDetector: var IntSet): bool =
     var cycleDetectorCopy: IntSet
     for a in t.kids:
       cycleDetectorCopy = cycleDetector
-      if isRecursiveStructuralType(a, cycleDetectorCopy):
-        return true
-  of tyProc:
-    result = false
-    var cycleDetectorCopy: IntSet
-    if t.returnType != nil:
-      cycleDetectorCopy = cycleDetector
-      if isRecursiveStructuralType(t.returnType, cycleDetectorCopy):
-        return true
-    for _, a in t.paramTypes:
-      cycleDetectorCopy = cycleDetector
-      if isRecursiveStructuralType(a, cycleDetectorCopy):
+      if isTupleRecursive(a, cycleDetectorCopy):
         return true
   of tyRef, tyPtr, tyVar, tyLent, tySink,
       tyArray, tyUncheckedArray, tySequence, tyDistinct:
-    return isRecursiveStructuralType(t.elementType, cycleDetector)
+    return isTupleRecursive(t.elementType, cycleDetector)
   of tyAlias, tyGenericInst:
-    return isRecursiveStructuralType(t.skipModifier, cycleDetector)
+    return isTupleRecursive(t.skipModifier, cycleDetector)
   else:
     return false
 
-proc isRecursiveStructuralType*(t: PType): bool =
+proc isTupleRecursive*(t: PType): bool =
   var cycleDetector = initIntSet()
-  isRecursiveStructuralType(t, cycleDetector)
+  isTupleRecursive(t, cycleDetector)
 
 proc isException*(t: PType): bool =
   # check if `y` is object type and it inherits from Exception
@@ -2005,126 +1935,3 @@ proc isCharArrayPtr*(t: PType; allowPointerToChar: bool): bool =
       result = false
   else:
     result = false
-
-proc isRefPtrObject*(t: PType): bool =
-  t.kind in {tyRef, tyPtr} and tfRefsAnonObj in t.flags
-
-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
-        isRefPtrObject(val):
-      # 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
-
-proc genericRoot*(t: PType): PType =
-  ## gets the root generic type (`tyGenericBody`) from `t`,
-  ## if `t` is a generic type or the body of a generic instantiation
-  case t.kind
-  of tyGenericBody:
-    result = t
-  of tyGenericInst, tyGenericInvocation:
-    result = t.genericHead
-  else:
-    if t.typeInst != nil:
-      result = t.typeInst.genericHead
-    elif t.sym != nil and t.sym.typ.kind == tyGenericBody:
-      # can happen if `t` is the last child (body) of the generic body
-      result = t.sym.typ
-    else:
-      result = nil
-
-proc reduceToBase*(f: PType): PType =
-  #[
-    Not recursion safe
-    Returns the lowest order (most general) type that that is compatible with the input.
-    E.g.
-    A[T] = ptr object ... A -> ptr object
-    A[N: static[int]] = array[N, int] ... A -> array
-  ]#
-  case f.kind:
-  of tyGenericParam:
-    if f.len <= 0 or f.skipModifier == nil:
-      result = f
-    else:
-      result = reduceToBase(f.skipModifier)
-  of tyGenericInvocation:
-    result = reduceToBase(f.baseClass)
-  of tyCompositeTypeClass, tyAlias:
-    if not f.hasElementType or f.elementType == nil:
-      result = f
-    else:
-      result = reduceToBase(f.elementType)
-  of tyGenericInst:
-    result = reduceToBase(f.skipModifier)
-  of tyGenericBody:
-    result = reduceToBase(f.typeBodyImpl)
-  of tyUserTypeClass:
-    if f.isResolvedUserTypeClass:
-      result = f.base
-    else:
-      result = f.skipModifier
-  of tyStatic, tyOwned, tyVar, tyLent, tySink:
-    result = reduceToBase(f.base)
-  of tyInferred:
-    # This is not true "After a candidate type is selected"
-    result = reduceToBase(f.base)
-  of tyRange:
-    result = f.elementType
-  else:
-    result = f

compiler/vm.nim

@@ -12,7 +12,7 @@
 
 import semmacrosanity
 import
-  std/[strutils, tables, intsets, parseutils],
+  std/[strutils, tables, parseutils],
   msgs, vmdef, vmgen, nimsets, types,
   parser, vmdeps, idents, trees, renderer, options, transf,
   gorgeimpl, lineinfos, btrees, macrocacheimpl,
@@ -480,9 +480,9 @@ proc opConv(c: PCtx; dest: var TFullReg, src: TFullReg, desttyp, srctyp: PType):
     else:
       asgnComplex(dest, src)
 
-proc compile(c: PCtx, s: PSym): VmProcInfo =
+proc compile(c: PCtx, s: PSym): int =
   result = vmgen.genProc(c, s)
-  when debugEchoCode: c.echoCode result.pc
+  when debugEchoCode: c.echoCode result
   #c.echoCode
 
 template handleJmpBack() {.dirty.} =
@@ -516,8 +516,6 @@ const
   errIllegalConvFromXtoY = "illegal conversion from '$1' to '$2'"
   errTooManyIterations = "interpretation requires too many iterations; " &
     "if you are sure this is not a bug in your code, compile with `--maxLoopIterationsVM:number` (current value: $1)"
-  errCallDepthExceeded = "maximum call depth for the VM exceeded; " &
-    "if you are sure this is not a bug in your code, compile with `--maxCallDepthVM:number` (current value: $1)"
   errFieldXNotFound = "node lacks field: "
 
 
@@ -592,7 +590,6 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       let newPc = c.cleanUpOnReturn(tos)
       # Perform any cleanup action before returning
       if newPc < 0:
-        inc(c.callDepth)
         pc = tos.comesFrom
         let retVal = regs[0]
         tos = tos.next
@@ -663,10 +660,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       of rkNode:
         if regs[rb].node.typ.kind notin PtrLikeKinds:
           stackTrace(c, tos, pc, "opcCastIntToPtr: regs[rb].node.typ: " & $regs[rb].node.typ.kind)
-        if regs[rb].node.kind == nkNilLit:
-          node2.intVal = 0
-        else:
-          node2.intVal = regs[rb].node.intVal
+        node2.intVal = regs[rb].node.intVal
       else: stackTrace(c, tos, pc, "opcCastIntToPtr: regs[rb].kind: " & $regs[rb].kind)
       regs[ra].node = node2
     of opcAsgnComplex:
@@ -862,9 +856,9 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
     of opcLdObj:
       # a = b.c
       decodeBC(rkNode)
-      if rb >= regs.len or regs[rb].kind == rkNone or
+      if rb >= regs.len or regs[rb].kind == rkNone or 
         (regs[rb].kind == rkNode and regs[rb].node == nil) or
-        (regs[rb].kind == rkNodeAddr and regs[rb].nodeAddr[] == nil):
+        (regs[rb].kind == rkNodeAddr and regs[rb].nodeAddr[] == nil): 
         stackTrace(c, tos, pc, errNilAccess)
       else:
         let src = if regs[rb].kind == rkNode: regs[rb].node else: regs[rb].nodeAddr[]
@@ -1438,39 +1432,23 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
         else:
           globalError(c.config, c.debug[pc], "VM not built with FFI support")
       elif prc.kind != skTemplate:
-        let procInfo = compile(c, prc)
+        let newPc = compile(c, prc)
         # tricky: a recursion is also a jump back, so we use the same
         # logic as for loops:
-        if procInfo.pc < pc: handleJmpBack()
+        if newPc < pc: handleJmpBack()
         #echo "new pc ", newPc, " calling: ", prc.name.s
         var newFrame = PStackFrame(prc: prc, comesFrom: pc, next: tos)
-        newSeq(newFrame.slots, procInfo.usedRegisters+ord(isClosure))
-        # setup slot for proc result:
-        let ret {.cursor.} = prc.typ.returnType
-        # hot spot ahead!
-        if ret != nil:
-          if fitsRegister(ret):
-            # same logic as opcLdNullReg here:
-            ensureKind(newFrame.slots[0], rkInt)
-            newFrame.slots[0].intVal = 0
-          elif not isEmptyType(ret):
-            putIntoReg(newFrame.slots[0], getNullValue(c, ret, prc.info, c.config))
+        newSeq(newFrame.slots, prc.offset+ord(isClosure))
+        if not isEmptyType(prc.typ.returnType):
+          putIntoReg(newFrame.slots[0], getNullValue(c, prc.typ.returnType, prc.info, c.config))
         for i in 1..rc-1:
           newFrame.slots[i] = regs[rb+i]
         if isClosure:
           newFrame.slots[rc] = TFullReg(kind: rkNode, node: regs[rb].node[1])
-        if c.callDepth <= 0:
-          if allowInfiniteRecursion in c.features:
-            c.callDepth = c.config.maxCallDepthVM
-          else:
-            msgWriteln(c.config, "stack trace: (most recent call last)", {msgNoUnitSep})
-            stackTraceAux(c, tos, pc)
-            globalError(c.config, c.debug[pc], errCallDepthExceeded % $c.config.maxCallDepthVM)
-        dec(c.callDepth)
         tos = newFrame
         updateRegsAlias
         # -1 for the following 'inc pc'
-        pc = procInfo.pc-1
+        pc = newPc-1
       else:
         # for 'getAst' support we need to support template expansion here:
         let genSymOwner = if tos.next != nil and tos.next.prc != nil:
@@ -1483,8 +1461,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
           let node = regs[rb+i].regToNode
           node.info = c.debug[pc]
           if prc.typ[i].kind notin {tyTyped, tyUntyped}:
-            var producedClosure = false
-            node.annotateType(prc.typ[i], c.config, producedClosure)
+            node.annotateType(prc.typ[i], c.config)
 
           macroCall.add(node)
         var a = evalTemplate(macroCall, prc, genSymOwner, c.config, c.cache, c.templInstCounter, c.idgen)
@@ -1726,12 +1703,6 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       let max = (1.BiggestInt shl (rb-1))-1
       if regs[ra].intVal < min or regs[ra].intVal > max:
         stackTrace(c, tos, pc, "unhandled exception: value out of range")
-    of opcNarrowR:
-      decodeBC(rkInt)
-      let min = regs[rb].intVal
-      let max = regs[rc].intVal
-      if regs[ra].intVal < min or regs[ra].intVal > max:
-        stackTrace(c, tos, pc, "unhandled exception: value out of range")
     of opcNarrowU:
       decodeB(rkInt)
       regs[ra].intVal = regs[ra].intVal and ((1'i64 shl rb)-1)
@@ -1891,7 +1862,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
           regs[ra].node = opMapTypeInstToAst(c.cache, regs[rb].node.sym.typ, c.debug[pc], c.idgen)
         else:
           stackTrace(c, tos, pc, "node has no type")
-      of 3:
+      else:
         # getTypeImpl opcode:
         ensureKind(rkNode)
         if regs[rb].kind == rkNode and regs[rb].node.typ != nil:
@@ -1900,15 +1871,6 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
           regs[ra].node = opMapTypeImplToAst(c.cache, regs[rb].node.sym.typ, c.debug[pc], c.idgen)
         else:
           stackTrace(c, tos, pc, "node has no type")
-      else:
-        # getTypeInstSkipAlias opcode:
-        ensureKind(rkNode)
-        if regs[rb].kind == rkNode and regs[rb].node.typ != nil:
-          regs[ra].node = opMapTypeInstToAst(c.cache, regs[rb].node.typ, c.debug[pc], c.idgen, skipAlias = true)
-        elif regs[rb].kind == rkNode and regs[rb].node.kind == nkSym and regs[rb].node.sym.typ != nil:
-          regs[ra].node = opMapTypeInstToAst(c.cache, regs[rb].node.sym.typ, c.debug[pc], c.idgen, skipAlias = true)
-        else:
-          stackTrace(c, tos, pc, "node has no type")
     of opcNGetSize:
       decodeBImm(rkInt)
       let n = regs[rb].node
@@ -2078,7 +2040,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
         aStrVal = aNode.ident.s.cstring
       of nkSym:
         aStrVal = aNode.sym.name.s.cstring
-      of nkOpenSymChoice, nkClosedSymChoice, nkOpenSym:
+      of nkOpenSymChoice, nkClosedSymChoice:
         aStrVal = aNode[0].sym.name.s.cstring
       else:
         discard
@@ -2090,7 +2052,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
         bStrVal = bNode.ident.s.cstring
       of nkSym:
         bStrVal = bNode.sym.name.s.cstring
-      of nkOpenSymChoice, nkClosedSymChoice, nkOpenSym:
+      of nkOpenSymChoice, nkClosedSymChoice:
         bStrVal = bNode[0].sym.name.s.cstring
       else:
         discard
@@ -2349,7 +2311,6 @@ proc execute(c: PCtx, start: int): PNode =
 
 proc execProc*(c: PCtx; sym: PSym; args: openArray[PNode]): PNode =
   c.loopIterations = c.config.maxLoopIterationsVM
-  c.callDepth = c.config.maxCallDepthVM
   if sym.kind in routineKinds:
     if sym.typ.paramsLen != args.len:
       result = nil
@@ -2360,7 +2321,8 @@ proc execProc*(c: PCtx; sym: PSym; args: openArray[PNode]): PNode =
       let start = genProc(c, sym)
 
       var tos = PStackFrame(prc: sym, comesFrom: 0, next: nil)
-      newSeq(tos.slots, start.usedRegisters)
+      let maxSlots = sym.offset
+      newSeq(tos.slots, maxSlots)
 
       # setup parameters:
       if not isEmptyType(sym.typ.returnType) or sym.kind == skMacro:
@@ -2369,7 +2331,7 @@ proc execProc*(c: PCtx; sym: PSym; args: openArray[PNode]): PNode =
       for i in 0..<sym.typ.paramsLen:
         putIntoReg(tos.slots[i+1], args[i])
 
-      result = rawExecute(c, start.pc, tos).regToNode
+      result = rawExecute(c, start, tos).regToNode
   else:
     result = nil
     localError(c.config, sym.info,
@@ -2451,12 +2413,9 @@ proc evalConstExprAux(module: PSym; idgen: IdGenerator;
   setupGlobalCtx(module, g, idgen)
   var c = PCtx g.vm
   let oldMode = c.mode
-  let oldLocals = c.locals
   c.mode = mode
-  c.locals = initIntSet()
   c.cannotEval = false
   let start = genExpr(c, n, requiresValue = mode!=emStaticStmt)
-  c.locals = oldLocals
   if c.cannotEval:
     return errorNode(idgen, prc, n)
   if c.code[start].opcode == opcEof: return newNodeI(nkEmpty, n.info)
@@ -2558,7 +2517,8 @@ proc evalMacroCall*(module: PSym; idgen: IdGenerator; g: ModuleGraph; templInstC
     return errorNode(idgen, module, n)
 
   var tos = PStackFrame(prc: sym, comesFrom: 0, next: nil)
-  newSeq(tos.slots, start.usedRegisters)
+  let maxSlots = sym.offset
+  newSeq(tos.slots, maxSlots)
   # setup arguments:
   var L = n.safeLen
   if L == 0: L = 1
@@ -2585,7 +2545,7 @@ proc evalMacroCall*(module: PSym; idgen: IdGenerator; g: ModuleGraph; templInstC
                  " generic parameter(s)")
   # temporary storage:
   #for i in L..<maxSlots: tos.slots[i] = newNode(nkEmpty)
-  result = rawExecute(c, start.pc, tos).regToNode
+  result = rawExecute(c, start, tos).regToNode
   if result.info.line < 0: result.info = n.info
   if cyclicTree(result): globalError(c.config, n.info, "macro produced a cyclic tree")
   dec(g.config.evalMacroCounter)

compiler/vmdef.nim

@@ -10,7 +10,7 @@
 ## This module contains the type definitions for the new evaluation engine.
 ## An instruction is 1-3 int32s in memory, it is a register based VM.
 
-import std/[tables, strutils, intsets]
+import std/[tables, strutils]
 
 import ast, idents, options, modulegraphs, lineinfos
 
@@ -105,7 +105,7 @@ type
     opcIsNil, opcOf, opcIs,
     opcParseFloat, opcConv, opcCast,
     opcQuit, opcInvalidField,
-    opcNarrowS, opcNarrowU, opcNarrowR
+    opcNarrowS, opcNarrowU,
     opcSignExtend,
 
     opcAddStrCh,
@@ -201,7 +201,6 @@ type
   TSandboxFlag* = enum        ## what the evaluation engine should allow
     allowCast,                ## allow unsafe language feature: 'cast'
     allowInfiniteLoops        ## allow endless loops
-    allowInfiniteRecursion    ## allow infinite recursion
   TSandboxFlags* = set[TSandboxFlag]
 
   TSlotKind* = enum   # We try to re-use slots in a smart way to
@@ -243,18 +242,12 @@ type
   VmCallback* = proc (args: VmArgs) {.closure.}
 
   PCtx* = ref TCtx
-
-  VmProcInfo* = object
-    pc*: int32
-    usedRegisters*: int32
-
   TCtx* = object of TPassContext # code gen context
     code*: seq[TInstr]
     debug*: seq[TLineInfo]  # line info for every instruction; kept separate
                             # to not slow down interpretation
     globals*: PNode         #
     constants*: PNode       # constant data
-    contstantTab*: TNodeTable
     types*: seq[PType]      # some instructions reference types (e.g. 'except')
     currentExceptionA*, currentExceptionB*: PNode
     exceptionInstr*: int # index of instruction that raised the exception
@@ -264,7 +257,7 @@ type
     mode*: TEvalMode
     features*: TSandboxFlags
     traceActive*: bool
-    loopIterations*, callDepth*: int
+    loopIterations*: int
     comesFromHeuristic*: TLineInfo # Heuristic for better macro stack traces
     callbacks*: seq[VmCallback]
     callbackIndex*: Table[string, int]
@@ -276,9 +269,8 @@ type
     profiler*: Profiler
     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, VmProcInfo]
+    procToCodePos*: Table[int, int]
     cannotEval*: bool
-    locals*: IntSet
 
   PStackFrame* = ref TStackFrame
   TStackFrame* {.acyclic.} = object
@@ -298,23 +290,17 @@ type
 
   PEvalContext* = PCtx
 
-const
-  NoVmProcInfo* = VmProcInfo(pc: 0'i32, usedRegisters: -1'i32)
-
 proc newCtx*(module: PSym; cache: IdentCache; g: ModuleGraph; idgen: IdGenerator): PCtx =
   PCtx(code: @[], debug: @[],
     globals: newNode(nkStmtListExpr), constants: newNode(nkStmtList), types: @[],
     prc: PProc(blocks: @[]), module: module, loopIterations: g.config.maxLoopIterationsVM,
-    callDepth: g.config.maxCallDepthVM,
     comesFromHeuristic: unknownLineInfo, callbacks: @[], callbackIndex: initTable[string, int](), errorFlag: "",
-    cache: cache, config: g.config, graph: g, idgen: idgen,
-    contstantTab: initNodeTable(true))
+    cache: cache, config: g.config, graph: g, idgen: idgen)
 
 proc refresh*(c: PCtx, module: PSym; idgen: IdGenerator) =
   c.module = module
   c.prc = PProc(blocks: @[])
   c.loopIterations = c.config.maxLoopIterationsVM
-  c.callDepth = c.config.maxCallDepthVM
   c.idgen = idgen
 
 proc reverseName(s: string): string =

compiler/vmdeps.nim

@@ -42,7 +42,7 @@ proc atomicTypeX(s: PSym; info: TLineInfo): PNode =
   result.info = info
 
 proc mapTypeToAstX(cache: IdentCache; t: PType; info: TLineInfo; idgen: IdGenerator;
-                   inst=false; allowRecursionX=false; skipAlias = false): PNode
+                   inst=false; allowRecursionX=false): PNode
 
 proc mapTypeToBracketX(cache: IdentCache; name: string; m: TMagic; t: PType; info: TLineInfo;
                        idgen: IdGenerator;
@@ -70,7 +70,7 @@ proc objectNode(cache: IdentCache; n: PNode; idgen: IdGenerator): PNode =
 
 proc mapTypeToAstX(cache: IdentCache; t: PType; info: TLineInfo;
                    idgen: IdGenerator;
-                   inst=false; allowRecursionX=false; skipAlias = false): PNode =
+                   inst=false; allowRecursionX=false): PNode =
   var allowRecursion = allowRecursionX
   template atomicType(name, m): untyped = atomicTypeX(cache, name, m, t, info, idgen)
   template atomicType(s): untyped = atomicTypeX(s, info)
@@ -91,8 +91,7 @@ proc mapTypeToAstX(cache: IdentCache; t: PType; info: TLineInfo;
     id
   template newIdentDefs(s): untyped = newIdentDefs(s, s.typ)
 
-  if inst and not allowRecursion and t.sym != nil and
-      not (skipAlias and t.kind == tyAlias):
+  if inst and not allowRecursion and t.sym != nil:
     # getTypeInst behavior: return symbol
     return atomicType(t.sym)
 
@@ -125,7 +124,7 @@ proc mapTypeToAstX(cache: IdentCache; t: PType; info: TLineInfo;
     if t.base != nil:
       result = newNodeIT(nkBracketExpr, if t.n.isNil: info else: t.n.info, t)
       result.add atomicType("typeDesc", mTypeDesc)
-      result.add mapTypeToAstX(cache, t.base, info, idgen, inst, skipAlias = skipAlias)
+      result.add mapTypeToAst(t.base, info)
     else:
       result = atomicType("typeDesc", mTypeDesc)
   of tyGenericInvocation:
@@ -154,7 +153,7 @@ proc mapTypeToAstX(cache: IdentCache; t: PType; info: TLineInfo;
     else:
       result = mapTypeToAst(t.typeBodyImpl, info)
   of tyAlias:
-    result = mapTypeToAstX(cache, t.skipModifier, info, idgen, inst, allowRecursion, skipAlias = skipAlias)
+    result = mapTypeToAstX(cache, t.skipModifier, info, idgen, inst, allowRecursion)
   of tyOrdinal:
     result = mapTypeToAst(t.skipModifier, info)
   of tyDistinct:
@@ -326,9 +325,8 @@ proc opMapTypeToAst*(cache: IdentCache; t: PType; info: TLineInfo; idgen: IdGene
 
 # the "Inst" version includes generic parameters in the resulting type tree
 # and also tries to look like the corresponding Nim type declaration
-proc opMapTypeInstToAst*(cache: IdentCache; t: PType; info: TLineInfo; idgen: IdGenerator; skipAlias = false): PNode =
-  # skipAlias: skips aliases and typedesc
-  result = mapTypeToAstX(cache, t, info, idgen, inst=true, allowRecursionX=false, skipAlias = skipAlias)
+proc opMapTypeInstToAst*(cache: IdentCache; t: PType; info: TLineInfo; idgen: IdGenerator): PNode =
+  result = mapTypeToAstX(cache, t, info, idgen, inst=true, allowRecursionX=false)
 
 # the "Impl" version includes generic parameters in the resulting type tree
 # and also tries to look like the corresponding Nim type implementation