fixes #24721; Table add missing sink

fixes #24702

.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

@@ -43,9 +43,9 @@ jobs:
           - target: linux
             os: ubuntu-22.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_packages.yml

@@ -18,13 +18,9 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, macos-latest]
-        batch: ["0_3", "1_3", "2_3"] # list of `index_num`
-        include:
-          - os: ubuntu-latest
-            cpu: amd64
-          - os: macos-latest
-            cpu: arm64
+        os: [ubuntu-22.04, macos-13]
+        cpu: [amd64]
+        batch: ["allowed_failures", "0_3", "1_3", "2_3"] # list of `index_num`
     name: '${{ matrix.os }} (batch: ${{ matrix.batch }})'
     runs-on: ${{ matrix.os }}
     timeout-minutes: 60 # refs bug #18178
@@ -45,11 +41,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

@@ -60,7 +60,7 @@ jobs:
         run: nim c -r -d:release ci/action.nim
 
       - name: 'Comment'
-        uses: actions/github-script@v9
+        uses: actions/github-script@v7
         with:
           script: |
             const fs = require('fs');
@@ -76,3 +76,4 @@ jobs:
             } catch (err) {
               console.error(err);
             }
+

.github/workflows/stale.yml

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

.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

@@ -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"
 

changelog.md

@@ -19,78 +19,15 @@ 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 `cpp`.
-
-- 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 `--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 do not trigger warnings. `int` to `Natural` and `Positive` conversions do not trigger warnings, which can be enabled with `--warning:systemRangeConversion`.
-
-- Procedure compatibility also checks the backend representation of the
-parameter and result types, not just their source-level shape. Use
-`--legacy:procParamTypeBackendAliases` to restore the older behavior.
-
 ## 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.
-- `system.setLenUninit` for the `string` type. Allows setting length without initializing new memory on growth.
-
-- `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.
-
-- `std/symlinks.expandSymlink` now supports Windows symlinks and junctions with
-  POSIX-like single-hop `readlink` semantics.
-- `std/nre2` is added to replace deprecated NRE.
-
-- `system.typeof` adds a new parameter `modifierMode` to specify how type modifiers are handled.
 
 [//]: # "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`.
-- `std/re` and `std/nre` are deprecated as PCRE library is obsolete.
-  Use https://github.com/nitely/nim-regex or `std/nre2`.
-  See: https://github.com/nim-lang/Nim/issues/23668.
-- `std/pegs` now correctly lexes UTF-8 bytes inside bare identifier-style
-  terminals, so case-insensitive matching of non-ASCII terms (e.g. ``\i café``)
-  works without single-quoting.
-- `std/uri`: The `?` operator now appends query parameters to an existing query
-  string instead of replacing it. Fixes [#19782](https://github.com/nim-lang/Nim/issues/19782).
-- `std/jsonutils`: `fromJson` now throws an exception when converting to `array`/`seq` if the JSON isn't an array instead of silently failing
 
 ## Language changes
 
@@ -131,24 +68,7 @@ parameter and result types, not just their source-level shape. Use
 
 ## 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.
-
-- The JS backend now implements write-through for `var openArray` parameters that
-  receive a `toOpenArray` view (bug #15952): mutations reach the caller's storage
-  instead of silently writing to a copy. Fixed homogeneous numeric arrays
-  (`array[N, T]`, JS typed arrays) slice via `subarray`; `seq` and non-numeric
-  arrays slice via a `{base, off, len}` view. This also covers seq/non-numeric-array
-  write-through, pass-through, re-slicing and `@` (openArray-to-seq) of such views.
 
 ## 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.

compiler/aliasanalysis.nim

@@ -8,7 +8,7 @@ const
                  nkBracketExpr, nkDerefExpr, nkHiddenDeref,
                  nkAddr, nkHiddenAddr,
                  nkObjDownConv, nkObjUpConv}
-  PathKinds1* = {nkHiddenStdConv, nkHiddenSubConv, nkCast}
+  PathKinds1* = {nkHiddenStdConv, nkHiddenSubConv}
 
 proc skipConvDfa*(n: PNode): PNode =
   result = n
@@ -125,3 +125,4 @@ proc aliases*(obj, field: PNode): AliasKind =
       else:
         result = maybe
     else: assert false # unreachable
+

compiler/aliases.nim

@@ -107,7 +107,7 @@ proc isPartOf*(a, b: PNode): TAnalysisResult =
   if a.kind == b.kind:
     case a.kind
     of nkSym:
-      const varKinds = {skVar, skTemp, skResult, skProc, skFunc}
+      const varKinds = {skVar, skTemp, skProc, skFunc}
       # same symbol: aliasing:
       if a.sym.id == b.sym.id: result = arYes
       elif a.sym.kind in varKinds or b.sym.kind in varKinds:

compiler/ast.nim

@@ -500,7 +500,6 @@ type
     mAppendStrCh, mAppendStrStr, mAppendSeqElem,
     mInSet, mRepr, mExit,
     mSetLengthStr, mSetLengthSeq,
-    mSetLengthSeqUninit,
     mIsPartOf, mAstToStr, mParallel,
     mSwap, mIsNil, mArrToSeq, mOpenArrayToSeq,
     mNewString, mNewStringOfCap, mParseBiggestFloat,
@@ -685,7 +684,6 @@ type
     symbols*: TStrTable
     parent*: PScope
     allowPrivateAccess*: seq[PSym] #  # enable access to private fields
-    optionStackLen*: int
 
   PScope* = ref TScope
 
@@ -797,15 +795,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 +805,6 @@ type
                                 # nodes are compared by structure!
     counter*: int
     data*: TNodePairSeq
-    ignoreTypes*: bool
 
   TObjectSeq* = seq[RootRef]
   TObjectSet* = object
@@ -945,17 +933,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 +1269,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 +1607,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 =
@@ -2117,20 +2089,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:
-      # A proc-typed value with no explicit raises slot still has
-      # unspecified effects, which sempass2 treats conservatively.
-      # Codegen needs to do the same in order to keep goto-exception
-      # checks after indirect/closure calls.
-      result = ((fn.typ.n[0].len < effectListLen) or
-        fn.typ.n[0][exceptionEffects] == nil or
-        fn.typ.n[0][exceptionEffects].safeLen > 0)
-  else:
-    result = false
+      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))
 
 proc toHumanStrImpl[T](kind: T, num: static int): string =
   result = $kind
@@ -2167,8 +2133,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/astyaml.nim

@@ -43,13 +43,13 @@ proc flagsToStr[T](flags: set[T]): string =
 proc lineInfoToStr*(conf: ConfigRef; info: TLineInfo): string =
   result = "["
   result.addYamlString(toFilename(conf, info))
-  result.addf ", $1, $2]", toLinenumber(info), toColumn(info)
+  result.addf ", $1, $2]", [toLinenumber(info), toColumn(info)]
 
-proc treeToYamlAux(res: var string; conf: ConfigRef; n: PNode; marker: var IntSet; nl: bool, indent, maxRecDepth: int)
-proc symToYamlAux(res: var string; conf: ConfigRef; n: PSym; marker: var IntSet; nl: bool, indent, maxRecDepth: int)
-proc typeToYamlAux(res: var string; conf: ConfigRef; n: PType; marker: var IntSet; nl: bool, indent, maxRecDepth: int)
+proc treeToYamlAux(res: var string; conf: ConfigRef; n: PNode; marker: var IntSet; indent, maxRecDepth: int)
+proc symToYamlAux(res: var string; conf: ConfigRef; n: PSym; marker: var IntSet; indent, maxRecDepth: int)
+proc typeToYamlAux(res: var string; conf: ConfigRef; n: PType; marker: var IntSet; indent, maxRecDepth: int)
 
-proc symToYamlAux(res: var string; conf: ConfigRef; n: PSym; marker: var IntSet; nl: bool, indent: int; maxRecDepth: int) =
+proc symToYamlAux(res: var string; conf: ConfigRef; n: PSym; marker: var IntSet; indent: int; maxRecDepth: int) =
   if n == nil:
     res.add("null")
   elif containsOrIncl(marker, n.id):
@@ -57,12 +57,10 @@ proc symToYamlAux(res: var string; conf: ConfigRef; n: PSym; marker: var IntSet;
   else:
     let istr = spaces(indent * 4)
 
-    if nl:
-      res.addf("\n$1", istr)
     res.addf("kind: $1", [makeYamlString($n.kind)])
     res.addf("\n$1name: $2", [istr, makeYamlString(n.name.s)])
     res.addf("\n$1typ: ", [istr])
-    res.typeToYamlAux(conf, n.typ, marker, true, indent + 1, maxRecDepth - 1)
+    res.typeToYamlAux(conf, n.typ, marker, indent + 1, maxRecDepth - 1)
     if conf != nil:
       # if we don't pass the config, we probably don't care about the line info
       res.addf("\n$1info: $2", [istr, lineInfoToStr(conf, n.info)])
@@ -70,7 +68,7 @@ proc symToYamlAux(res: var string; conf: ConfigRef; n: PSym; marker: var IntSet;
       res.addf("\n$1flags: $2", [istr, flagsToStr(n.flags)])
     res.addf("\n$1magic: $2", [istr, makeYamlString($n.magic)])
     res.addf("\n$1ast: ", [istr])
-    res.treeToYamlAux(conf, n.ast, marker, true, indent + 1, maxRecDepth - 1)
+    res.treeToYamlAux(conf, n.ast, marker, indent + 1, maxRecDepth - 1)
     res.addf("\n$1options: $2", [istr, flagsToStr(n.options)])
     res.addf("\n$1position: $2", [istr, $n.position])
     res.addf("\n$1k: $2", [istr, makeYamlString($n.loc.k)])
@@ -78,57 +76,53 @@ proc symToYamlAux(res: var string; conf: ConfigRef; n: PSym; marker: var IntSet;
     if card(n.loc.flags) > 0:
       res.addf("\n$1flags: $2", [istr, makeYamlString($n.loc.flags)])
     res.addf("\n$1snippet: $2", [istr, n.loc.snippet])
-    res.addf("\n$1lode: ", [istr])
-    res.treeToYamlAux(conf, n.loc.lode, marker, true, indent + 1, maxRecDepth - 1)
+    res.addf("\n$1lode: $2", [istr])
+    res.treeToYamlAux(conf, n.loc.lode, marker, indent + 1, maxRecDepth - 1)
 
-proc typeToYamlAux(res: var string; conf: ConfigRef; n: PType; marker: var IntSet; nl: bool, indent: int; maxRecDepth: int) =
+proc typeToYamlAux(res: var string; conf: ConfigRef; n: PType; marker: var IntSet; indent: int; maxRecDepth: int) =
   if n == nil:
     res.add("null")
   elif containsOrIncl(marker, n.id):
     res.addf "\"$1 @$2\"" % [$n.kind, strutils.toHex(cast[uint](n), sizeof(n) * 2)]
   else:
     let istr = spaces(indent * 4)
-    if nl:
-      res.addf("\n$1", istr)
     res.addf("kind: $2", [istr, makeYamlString($n.kind)])
-    res.addf("\n$1sym: ", istr)
-    res.symToYamlAux(conf, n.sym, marker, true, indent + 1, maxRecDepth - 1)
-    res.addf("\n$1n: ", istr)
-    res.treeToYamlAux(conf, n.n, marker, true, indent + 1, maxRecDepth - 1)
+    res.addf("\n$1sym: ")
+    res.symToYamlAux(conf, n.sym, marker, indent + 1, maxRecDepth - 1)
+    res.addf("\n$1n: ")
+    res.treeToYamlAux(conf, n.n, marker, indent + 1, maxRecDepth - 1)
     if card(n.flags) > 0:
       res.addf("\n$1flags: $2", [istr, flagsToStr(n.flags)])
     res.addf("\n$1callconv: $2", [istr, makeYamlString($n.callConv)])
     res.addf("\n$1size: $2", [istr, $(n.size)])
     res.addf("\n$1align: $2", [istr, $(n.align)])
     if n.hasElementType:
-      res.addf("\n$1sons:", istr)
+      res.addf("\n$1sons:")
       for a in n.kids:
-        res.addf("\n$1  - ", istr)
-        res.typeToYamlAux(conf, a, marker, false, indent + 1, maxRecDepth - 1)
+        res.addf("\n  - ")
+        res.typeToYamlAux(conf, a, marker, indent + 1, maxRecDepth - 1)
 
-proc treeToYamlAux(res: var string; conf: ConfigRef; n: PNode; marker: var IntSet; nl: bool, indent: int;
+proc treeToYamlAux(res: var string; conf: ConfigRef; n: PNode; marker: var IntSet; indent: int;
                    maxRecDepth: int) =
   if n == nil:
     res.add("null")
   else:
     var istr = spaces(indent * 4)
-    if nl:
-      res.addf("\n$1", istr)
     res.addf("kind: $1" % [makeYamlString($n.kind)])
 
     if maxRecDepth != 0:
       if conf != nil:
         res.addf("\n$1info: $2", [istr, lineInfoToStr(conf, n.info)])
       case n.kind
-      of nkCharLit .. nkUInt64Lit:
+      of nkCharLit .. nkInt64Lit:
         res.addf("\n$1intVal: $2", [istr, $(n.intVal)])
-      of nkFloatLit .. nkFloat128Lit:
+      of nkFloatLit, nkFloat32Lit, nkFloat64Lit:
         res.addf("\n$1floatVal: $2", [istr, n.floatVal.toStrMaxPrecision])
       of nkStrLit .. nkTripleStrLit:
         res.addf("\n$1strVal: $2", [istr, makeYamlString(n.strVal)])
       of nkSym:
         res.addf("\n$1sym: ", [istr])
-        res.symToYamlAux(conf, n.sym, marker, true, indent + 1, maxRecDepth)
+        res.symToYamlAux(conf, n.sym, marker, indent + 1, maxRecDepth)
       of nkIdent:
         if n.ident != nil:
           res.addf("\n$1ident: $2", [istr, makeYamlString(n.ident.s)])
@@ -139,22 +133,22 @@ proc treeToYamlAux(res: var string; conf: ConfigRef; n: PNode; marker: var IntSe
           res.addf("\n$1sons: ", [istr])
           for i in 0 ..< n.len:
             res.addf("\n$1  - ", [istr])
-            res.treeToYamlAux(conf, n[i], marker, false, indent + 1, maxRecDepth - 1)
+            res.treeToYamlAux(conf, n[i], marker, indent + 1, maxRecDepth - 1)
       if n.typ != nil:
         res.addf("\n$1typ: ", [istr])
-        res.typeToYamlAux(conf, n.typ, marker, true, indent + 1, maxRecDepth)
+        res.typeToYamlAux(conf, n.typ, marker, indent + 1, maxRecDepth)
 
 proc treeToYaml*(conf: ConfigRef; n: PNode; indent: int = 0; maxRecDepth: int = -1): string =
   var marker = initIntSet()
   result = newStringOfCap(1024)
-  result.treeToYamlAux(conf, n, marker, false, indent, maxRecDepth)
+  result.treeToYamlAux(conf, n, marker, indent, maxRecDepth)
 
 proc typeToYaml*(conf: ConfigRef; n: PType; indent: int = 0; maxRecDepth: int = -1): string =
   var marker = initIntSet()
   result = newStringOfCap(1024)
-  result.typeToYamlAux(conf, n, marker, false, indent, maxRecDepth)
+  result.typeToYamlAux(conf, n, marker, indent, maxRecDepth)
 
 proc symToYaml*(conf: ConfigRef; n: PSym; indent: int = 0; maxRecDepth: int = -1): string =
   var marker = initIntSet()
   result = newStringOfCap(1024)
-  result.symToYamlAux(conf, n, marker, false, indent, maxRecDepth)
+  result.symToYamlAux(conf, n, marker, indent, maxRecDepth)

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,164 @@
+import ropes, int128
+
+type
+  Snippet* = string
+  Builder* = object
+    buf*: string
+    indents*: int
+
+template newBuilder*(s: string): Builder =
+  Builder(buf: s)
+
+proc extract*(builder: Builder): Snippet =
+  builder.buf
+
+proc add*(builder: var Builder, s: string) =
+  builder.buf.add(s)
+
+proc add*(builder: var Builder, s: char) =
+  builder.buf.add(s)
+
+proc addNewline*(builder: var Builder) =
+  builder.add('\n')
+  for i in 0 ..< builder.indents:
+    builder.add('\t')
+
+proc addLineEnd*(builder: var Builder, s: string) =
+  builder.add(s)
+  builder.addNewline()
+
+proc addLineEndIndent*(builder: var Builder, s: string) =
+  inc builder.indents
+  builder.add(s)
+  builder.addNewline()
+
+proc addDedent*(builder: var Builder, s: string) =
+  if builder.buf.len > 0 and builder.buf[^1] == '\t':
+    builder.buf.setLen(builder.buf.len - 1)
+  builder.add(s)
+  dec builder.indents
+
+proc addLineEndDedent*(builder: var Builder, s: string) =
+  builder.addDedent(s)
+  builder.addNewline()
+
+proc addLineComment*(builder: var Builder, comment: string) =
+  # probably no-op on nifc
+  builder.add("// ")
+  builder.add(comment)
+  builder.addNewline()
+
+proc addIntValue*(builder: var Builder, val: int) =
+  builder.buf.addInt(val)
+
+proc addIntValue*(builder: var Builder, val: int64) =
+  builder.buf.addInt(val)
+
+proc addIntValue*(builder: var Builder, val: uint64) =
+  builder.buf.addInt(val)
+
+proc addIntValue*(builder: var Builder, val: Int128) =
+  builder.buf.addInt128(val)
+
+template cIntValue*(val: int): Snippet = $val
+template cIntValue*(val: int64): Snippet = $val
+template cIntValue*(val: uint64): Snippet = $val
+template cIntValue*(val: Int128): Snippet = $val
+
+template cUintValue*(val: uint): Snippet = $val & "U"
+
+import std/formatfloat
+
+proc addFloatValue*(builder: var Builder, val: float) =
+  builder.buf.addFloat(val)
+
+template cFloatValue*(val: float): Snippet = $val
+
+proc addInt64Literal*(result: var Builder; i: BiggestInt) =
+  if i > low(int64):
+    result.add "IL64($1)" % [rope(i)]
+  else:
+    result.add "(IL64(-9223372036854775807) - IL64(1))"
+
+proc addUint64Literal*(result: var Builder; i: uint64) =
+  result.add rope($i & "ULL")
+
+proc addIntLiteral*(result: var Builder; i: BiggestInt) =
+  if i > low(int32) and i <= high(int32):
+    result.addIntValue(i)
+  elif i == low(int32):
+    # Nim has the same bug for the same reasons :-)
+    result.add "(-2147483647 -1)"
+  elif i > low(int64):
+    result.add "IL64($1)" % [rope(i)]
+  else:
+    result.add "(IL64(-9223372036854775807) - IL64(1))"
+
+proc addIntLiteral*(result: var Builder; i: Int128) =
+  addIntLiteral(result, toInt64(i))
+
+proc cInt64Literal*(i: BiggestInt): Snippet =
+  if i > low(int64):
+    result = "IL64($1)" % [rope(i)]
+  else:
+    result = "(IL64(-9223372036854775807) - IL64(1))"
+
+proc cUint64Literal*(i: uint64): Snippet =
+  result = $i & "ULL"
+
+proc cIntLiteral*(i: BiggestInt): Snippet =
+  if i > low(int32) and i <= high(int32):
+    result = rope(i)
+  elif i == low(int32):
+    # Nim has the same bug for the same reasons :-)
+    result = "(-2147483647 -1)"
+  elif i > low(int64):
+    result = "IL64($1)" % [rope(i)]
+  else:
+    result = "(IL64(-9223372036854775807) - IL64(1))"
+
+proc cIntLiteral*(i: Int128): Snippet =
+  result = cIntLiteral(toInt64(i))
+
+const
+  NimInt* = "NI"
+  NimInt8* = "NI8"
+  NimInt16* = "NI16"
+  NimInt32* = "NI32"
+  NimInt64* = "NI64"
+  CInt* = "int"
+  NimUint* = "NU"
+  NimUint8* = "NU8"
+  NimUint16* = "NU16"
+  NimUint32* = "NU32"
+  NimUint64* = "NU64"
+  NimFloat* = "NF"
+  NimFloat32* = "NF32"
+  NimFloat64* = "NF64"
+  NimFloat128* = "NF128" # not actually defined
+  NimNan* = "NAN"
+  NimInf* = "INF"
+  NimBool* = "NIM_BOOL"
+  NimTrue* = "NIM_TRUE"
+  NimFalse* = "NIM_FALSE"
+  NimChar* = "NIM_CHAR"
+  CChar* = "char"
+  NimCstring* = "NCSTRING"
+  NimNil* = "NIM_NIL"
+  CNil* = "NULL"
+  NimStrlitFlag* = "NIM_STRLIT_FLAG"
+  CVoid* = "void"
+  CPointer* = "void*"
+  CConstPointer* = "NIM_CONST void*"
+
+proc cIntType*(bits: BiggestInt): Snippet =
+  "NI" & $bits
+
+proc cUintType*(bits: BiggestInt): Snippet =
+  "NU" & $bits
+
+type
+  IfBuilderState* = enum
+    WaitingIf, WaitingElseIf, InBlock
+  IfBuilder* = object
+    state*: IfBuilderState

compiler/cbuilderdecls.nim

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

compiler/cbuilderexprs.nim

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

compiler/cbuilderstmts.nim

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

compiler/ccgcalls.nim

@@ -11,11 +11,7 @@
 
 proc canRaiseDisp(p: BProc; n: PNode): bool =
   # we assume things like sysFatal cannot raise themselves
-  if n.kind == nkSym and n.sym.kind == skMethod:
-    # A base method may be overridden by a branch with a wider exception set.
-    # Its inferred effects describe only the base body, not every vtable target.
-    result = true
-  elif n.kind == nkSym and {sfNeverRaises, sfImportc, sfCompilerProc} * n.sym.flags != {}:
+  if n.kind == nkSym and {sfNeverRaises, sfImportc, sfCompilerProc} * n.sym.flags != {}:
     result = false
   elif optPanics in p.config.globalOptions or
       (n.kind == nkSym and sfSystemModule in getModule(n.sym).flags and
@@ -88,20 +84,21 @@ proc cleanupTemp(p: BProc; returnType: PType, tmp: TLoc): bool =
     let dtor = getAttachedOp(p.module.g.graph, returnType, attachedDestructor)
     var op = initLocExpr(p, newSymNode(dtor))
     var callee = rdLoc(op)
-    let destroy = if dtor.typ.firstParamType.kind == tyVar:
-        callee & "(&" & rdLoc(tmp) & ")"
+    let destroyArg =
+      if dtor.typ.firstParamType.kind == tyVar:
+        cAddr(rdLoc(tmp))
       else:
-        callee & "(" & rdLoc(tmp) & ")"
+        rdLoc(tmp)
+    let destroy = cCall(callee, destroyArg)
     raiseExitCleanup(p, destroy)
     result = true
   else:
     result = false
 
 proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
-               callee, params: Rope) =
+               result: var Builder, call: var CallBuilder) =
   let canRaise = p.config.exc == excGoto and canRaiseDisp(p, ri[0])
   genLineDir(p, ri)
-  var pl = callee & "(" & params
   # getUniqueType() is too expensive here:
   var typ = skipTypes(ri[0].typ, abstractInst)
   if typ.returnType != nil:
@@ -110,7 +107,6 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
       # perhaps generate no temp if the call doesn't have side effects
       flags.incl needTempForOpenArray
     if isInvalidReturnType(p.config, typ):
-      if params.len != 0: pl.add(", ")
       # beware of 'result = p(result)'. We may need to allocate a temporary:
       if d.k in {locTemp, locNone} or not preventNrvo(p, d.lode, le, ri):
         # Great, we can use 'd':
@@ -118,33 +114,39 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
         elif d.k notin {locTemp} and not hasNoInit(ri):
           # reset before pass as 'result' var:
           discard "resetLoc(p, d)"
-        pl.add(addrLoc(p.config, d))
-        pl.add(");\n")
-        line(p, cpsStmts, pl)
+        let rad = addrLoc(p.config, d)
+        result.addArgument(call):
+          result.add(rad)
+        result.finishCallBuilder(call)
+        p.s(cpsStmts).addStmt():
+          p.s(cpsStmts).add(extract(result))
       else:
         var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
-        pl.add(addrLoc(p.config, tmp))
-        pl.add(");\n")
-        line(p, cpsStmts, pl)
+        let ratmp = addrLoc(p.config, tmp)
+        result.addArgument(call):
+          result.add(ratmp)
+        result.finishCallBuilder(call)
+        p.s(cpsStmts).addStmt():
+          p.s(cpsStmts).add(extract(result))
         genAssignment(p, d, tmp, {}) # no need for deep copying
       if canRaise: raiseExit(p)
     else:
-      pl.add(")")
+      result.finishCallBuilder(call)
       if p.module.compileToCpp:
         if lfSingleUse in d.flags:
           # do not generate spurious temporaries for C++! For C we're better off
           # with them to prevent undefined behaviour and because the codegen
           # is free to emit expressions multiple times!
           d.k = locCall
-          d.snippet = pl
+          d.snippet = extract(result)
           excl d.flags, lfSingleUse
         else:
           if d.k == locNone and p.splitDecls == 0 and p.config.exc != excGoto:
-            d = getTempCpp(p, typ.returnType, pl)
+            d = getTempCpp(p, typ.returnType, extract(result))
           else:
             if d.k == locNone: d = getTemp(p, typ.returnType)
             var list = initLoc(locCall, d.lode, OnUnknown)
-            list.snippet = pl
+            list.snippet = extract(result)
             genAssignment(p, d, list, {needAssignCall}) # no need for deep copying
             if canRaise: raiseExit(p)
 
@@ -155,7 +157,7 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
           d = getTemp(p, typ.returnType)
         assert(d.t != nil)        # generate an assignment to d:
         var list = initLoc(locCall, d.lode, OnUnknown)
-        list.snippet = pl
+        list.snippet = extract(result)
         genAssignment(p, d, list, flags+{needAssignCall}) # no need for deep copying
         if canRaise:
           if not (useTemp and cleanupTemp(p, typ.returnType, d)):
@@ -163,15 +165,16 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
       else:
         var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
         var list = initLoc(locCall, d.lode, OnUnknown)
-        list.snippet = pl
+        list.snippet = extract(result)
         genAssignment(p, tmp, list, flags+{needAssignCall}) # no need for deep copying
         if canRaise:
           if not cleanupTemp(p, typ.returnType, tmp):
             raiseExit(p)
         genAssignment(p, d, tmp, {})
   else:
-    pl.add(");\n")
-    line(p, cpsStmts, pl)
+    finishCallBuilder(result, call)
+    p.s(cpsStmts).addStmt():
+      p.s(cpsStmts).add(extract(result))
     if canRaise: raiseExit(p)
 
 proc genBoundsCheck(p: BProc; arr, a, b: TLoc; arrTyp: PType)
@@ -203,49 +206,49 @@ proc genOpenArraySlice(p: BProc; q: PNode; formalType, destType: PType; prepareF
   if optBoundsCheck in p.options:
     genBoundsCheck(p, a, b, c, ty)
   if prepareForMutation:
-    linefmt(p, cpsStmts, "#nimPrepareStrMutationV2($1);$n", [byRefLoc(p, a)])
+    let bra = byRefLoc(p, a)
+    p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimPrepareStrMutationV2"),
+      bra)
   let dest = getTypeDesc(p.module, destType)
-  let lengthExpr = "($1)-($2)+1" % [rdLoc(c), rdLoc(b)]
+  let ra = rdLoc(a)
+  let rb = rdLoc(b)
+  let rc = rdLoc(c)
+  let lengthExpr = cOp(Add, NimInt, cOp(Sub, NimInt, rc, rb), cIntValue(1))
   case ty.kind
   of tyArray:
     let first = toInt64(firstOrd(p.config, ty))
     if first == 0:
-      result = ("($3*)(($1)+($2))" % [rdLoc(a), rdLoc(b), dest],
-                lengthExpr)
+      result = (cCast(ptrType(dest), cOp(Add, NimInt, ra, rb)), lengthExpr)
     else:
-      var lit = newRopeAppender()
-      intLiteral(first, lit)
-      result = ("($4*)($1)+(($2)-($3))" %
-        [rdLoc(a), rdLoc(b), lit, dest],
-        lengthExpr)
+      let lit = cIntLiteral(first)
+      result = (cCast(ptrType(dest), cOp(Add, NimInt, ra, cOp(Sub, NimInt, rb, lit))), lengthExpr)
   of tyOpenArray, tyVarargs:
-    if reifiedOpenArray(q[1]):
-      result = ("($3*)($1.Field0)+($2)" % [rdLoc(a), rdLoc(b), dest],
-                lengthExpr)
-    else:
-      result = ("($3*)($1)+($2)" % [rdLoc(a), rdLoc(b), dest],
-                lengthExpr)
+    let data = if reifiedOpenArray(q[1]): dotField(ra, "Field0") else: ra
+    result = (cCast(ptrType(dest), cOp(Add, NimInt, data, rb)), lengthExpr)
   of tyUncheckedArray, tyCstring:
-    result = ("($3*)($1)+($2)" % [rdLoc(a), rdLoc(b), dest],
-              lengthExpr)
+    result = (cCast(ptrType(dest), cOp(Add, NimInt, ra, rb)), lengthExpr)
   of tyString, tySequence:
     let atyp = skipTypes(a.t, abstractInst)
     if formalType.skipTypes(abstractInst).kind in {tyVar} and atyp.kind == tyString and
         optSeqDestructors in p.config.globalOptions:
-      linefmt(p, cpsStmts, "#nimPrepareStrMutationV2($1);$n", [byRefLoc(p, a)])
+      let bra = byRefLoc(p, a)
+      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimPrepareStrMutationV2"),
+        bra)
+    var val: Snippet
     if atyp.kind in {tyVar} and not compileToCpp(p.module):
-      result = ("(($5) ? (($4*)(*$1)$3+($2)) : NIM_NIL)" %
-                  [rdLoc(a), rdLoc(b), dataField(p), dest, dataFieldAccessor(p, "*" & rdLoc(a))],
-                lengthExpr)
+      val = cDeref(ra)
     else:
-      result = ("(($5) ? (($4*)$1$3+($2)) : NIM_NIL)" %
-                  [rdLoc(a), rdLoc(b), dataField(p), dest, dataFieldAccessor(p, rdLoc(a))],
-                lengthExpr)
+      val = ra
+    result = (
+      cIfExpr(dataFieldAccessor(p, val),
+        cCast(ptrType(dest), cOp(Add, NimInt, dataField(p, val), rb)),
+        NimNil),
+      lengthExpr)
   else:
     result = ("", "")
     internalError(p.config, "openArrayLoc: " & typeToString(a.t))
 
-proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Rope) =
+proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Builder) =
   var q = skipConv(n)
   var skipped = false
   while q.kind == nkStmtListExpr and q.len > 0:
@@ -260,42 +263,66 @@ proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Rope) =
           genStmts(p, q[i])
         q = q.lastSon
     let (x, y) = genOpenArraySlice(p, q, formalType, n.typ.elementType)
-    result.add x & ", " & y
+    result.add(x)
+    result.addArgumentSeparator()
+    result.add(y)
   else:
     var a = initLocExpr(p, if n.kind == nkHiddenStdConv: n[1] else: n)
     case skipTypes(a.t, abstractVar+{tyStatic}).kind
     of tyOpenArray, tyVarargs:
+      let ra = rdLoc(a)
       if reifiedOpenArray(n):
         if a.t.kind in {tyVar, tyLent}:
-          result.add "$1->Field0, $1->Field1" % [rdLoc(a)]
+          result.add(derefField(ra, "Field0"))
+          result.addArgumentSeparator()
+          result.add(derefField(ra, "Field1"))
         else:
-          result.add "$1.Field0, $1.Field1" % [rdLoc(a)]
+          result.add(dotField(ra, "Field0"))
+          result.addArgumentSeparator()
+          result.add(dotField(ra, "Field1"))
       else:
-        result.add "$1, $1Len_0" % [rdLoc(a)]
+        result.add(ra)
+        result.addArgumentSeparator()
+        result.add(ra & "Len_0")
     of tyString, tySequence:
       let ntyp = skipTypes(n.typ, abstractInst)
       if formalType.skipTypes(abstractInst).kind in {tyVar} and ntyp.kind == tyString and
           optSeqDestructors in p.config.globalOptions:
-        linefmt(p, cpsStmts, "#nimPrepareStrMutationV2($1);$n", [byRefLoc(p, a)])
+        let bra = byRefLoc(p, a)
+        p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimPrepareStrMutationV2"),
+          bra)
       if ntyp.kind in {tyVar} and not compileToCpp(p.module):
-        var t = TLoc(snippet: "(*$1)" % [a.rdLoc])
-        result.add "($4) ? ((*$1)$3) : NIM_NIL, $2" %
-                     [a.rdLoc, lenExpr(p, t), dataField(p),
-                      dataFieldAccessor(p, "*" & a.rdLoc)]
+        let ra = a.rdLoc
+        var t = TLoc(snippet: cDeref(ra))
+        let lt = lenExpr(p, t)
+        result.add(cIfExpr(dataFieldAccessor(p, t.snippet), dataField(p, t.snippet), NimNil))
+        result.addArgumentSeparator()
+        result.add(lt)
       else:
-        result.add "($4) ? ($1$3) : NIM_NIL, $2" %
-                     [a.rdLoc, lenExpr(p, a), dataField(p), dataFieldAccessor(p, a.rdLoc)]
+        let ra = a.rdLoc
+        let la = lenExpr(p, a)
+        result.add(cIfExpr(dataFieldAccessor(p, ra), dataField(p, ra), NimNil))
+        result.addArgumentSeparator()
+        result.add(la)
     of tyArray:
-      result.add "$1, $2" % [rdLoc(a), rope(lengthOrd(p.config, a.t))]
+      let ra = rdLoc(a)
+      result.add(ra)
+      result.addArgumentSeparator()
+      result.addIntValue(lengthOrd(p.config, a.t))
     of tyPtr, tyRef:
       case elementType(a.t).kind
       of tyString, tySequence:
-        var t = TLoc(snippet: "(*$1)" % [a.rdLoc])
-        result.add "($4) ? ((*$1)$3) : NIM_NIL, $2" %
-                     [a.rdLoc, lenExpr(p, t), dataField(p),
-                      dataFieldAccessor(p, "*" & a.rdLoc)]
+        let ra = a.rdLoc
+        var t = TLoc(snippet: cDeref(ra))
+        let lt = lenExpr(p, t)
+        result.add(cIfExpr(dataFieldAccessor(p, t.snippet), dataField(p, t.snippet), NimNil))
+        result.addArgumentSeparator()
+        result.add(lt)
       of tyArray:
-        result.add "$1, $2" % [rdLoc(a), rope(lengthOrd(p.config, elementType(a.t)))]
+        let ra = rdLoc(a)
+        result.add(ra)
+        result.addArgumentSeparator()
+        result.addIntValue(lengthOrd(p.config, elementType(a.t)))
       else:
         internalError(p.config, "openArrayLoc: " & typeToString(a.t))
     else: internalError(p.config, "openArrayLoc: " & typeToString(a.t))
@@ -311,15 +338,16 @@ proc withTmpIfNeeded(p: BProc, a: TLoc, needsTmp: bool): TLoc =
   else:
     result = a
 
-proc expressionsNeedsTmp(p: BProc, a: TLoc): TLoc =
+proc literalsNeedsTmp(p: BProc, a: TLoc): TLoc =
   result = getTemp(p, a.lode.typ, needsInit=false)
   genAssignment(p, result, a, {})
 
-proc genArgStringToCString(p: BProc, n: PNode; result: var Rope; needsTmp: bool) {.inline.} =
+proc genArgStringToCString(p: BProc, n: PNode; result: var Builder; needsTmp: bool) {.inline.} =
   var a = initLocExpr(p, n[0])
-  appcg(p.module, result, "#nimToCStringConv($1)", [withTmpIfNeeded(p, a, needsTmp).rdLoc])
+  let ra = withTmpIfNeeded(p, a, needsTmp).rdLoc
+  result.addCall(cgsymValue(p.module, "nimToCStringConv"), ra)
 
-proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Rope; needsTmp = false) =
+proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Builder; needsTmp = false) =
   var a: TLoc
   if n.kind == nkStringToCString:
     genArgStringToCString(p, n, result, needsTmp)
@@ -330,7 +358,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
@@ -360,12 +388,11 @@ proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Rope; need
     if param.typ.kind in {tyVar, tyPtr, tyRef, tySink}:
       let typ = skipTypes(param.typ, abstractPtrs)
       if not sameBackendTypePickyAliases(typ, n.typ.skipTypes(abstractPtrs)):
-        a.snippet = "(($1) ($2))" %
-          [getTypeDesc(p.module, param.typ), rdCharLoc(a)]
+        a.snippet = cCast(getTypeDesc(p.module, param.typ), rdCharLoc(a))
     addRdLoc(withTmpIfNeeded(p, a, needsTmp), result)
   #assert result != nil
 
-proc genArgNoParam(p: BProc, n: PNode; result: var Rope; needsTmp = false) =
+proc genArgNoParam(p: BProc, n: PNode; result: var Builder; needsTmp = false) =
   var a: TLoc
   if n.kind == nkStringToCString:
     genArgStringToCString(p, n, result, needsTmp)
@@ -428,7 +455,7 @@ proc getPotentialReads(n: PNode; result: var seq[PNode]) =
     for s in n:
       getPotentialReads(s, result)
 
-proc genParams(p: BProc, ri: PNode, typ: PType; result: var Rope) =
+proc genParams(p: BProc, ri: PNode, typ: PType; result: var Builder, argBuilder: var CallBuilder) =
   # We must generate temporaries in cases like #14396
   # to keep the strict Left-To-Right evaluation
   var needTmp = newSeq[bool](ri.len - 1)
@@ -450,21 +477,22 @@ proc genParams(p: BProc, ri: PNode, typ: PType; result: var Rope) =
         # Optimization: don't use a temp, if we would only take the address anyway
         needTmp[i - 1] = false
 
-  var oldLen = result.len
   for i in 1..<ri.len:
     if i < typ.n.len:
       assert(typ.n[i].kind == nkSym)
       let paramType = typ.n[i]
       if not paramType.typ.isCompileTimeOnly:
-        if oldLen != result.len:
-          result.add(", ")
-          oldLen = result.len
-        genArg(p, ri[i], paramType.sym, ri, result, needTmp[i-1])
+        var arg = newBuilder("")
+        genArg(p, ri[i], paramType.sym, ri, arg, needTmp[i-1])
+        if arg.buf.len != 0:
+          result.addArgument(argBuilder):
+            result.add(extract(arg))
     else:
-      if oldLen != result.len:
-        result.add(", ")
-        oldLen = result.len
-      genArgNoParam(p, ri[i], result, needTmp[i-1])
+      var arg = newBuilder("")
+      genArgNoParam(p, ri[i], arg, needTmp[i-1])
+      if arg.buf.len != 0:
+        result.addArgument(argBuilder):
+          result.add(extract(arg))
 
 proc addActualSuffixForHCR(res: var Rope, module: PSym, sym: PSym) =
   if sym.flags * {sfImportc, sfNonReloadable} == {} and sym.loc.k == locProc and
@@ -478,21 +506,39 @@ proc genPrefixCall(p: BProc, le, ri: PNode, d: var TLoc) =
   var typ = skipTypes(ri[0].typ, abstractInstOwned)
   assert(typ.kind == tyProc)
 
-  var params = newRopeAppender()
-  genParams(p, ri, typ, params)
-
   var callee = rdLoc(op)
   if p.hcrOn and ri[0].kind == nkSym:
     callee.addActualSuffixForHCR(p.module.module, ri[0].sym)
-  fixupCall(p, le, ri, d, callee, params)
+
+  var res = newBuilder("")
+  var call = initCallBuilder(res, callee)
+  genParams(p, ri, typ, res, call)
+  fixupCall(p, le, ri, d, res, call)
 
 proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
 
-  proc addComma(r: Rope): Rope =
-    if r.len == 0: r else: r & ", "
+  template callProc(rp, params, pTyp: Snippet): Snippet =
+    let e = dotField(rp, "ClE_0")
+    let p = dotField(rp, "ClP_0")
+    let eCall =
+      # note `params` here is actually multiple params
+      if params.len == 0:
+        cCall(p, e)
+      else:
+        cCall(p, params, e)
+    cIfExpr(e,
+      eCall, 
+      cCall(cCast(pTyp, p), params))
 
-  const PatProc = "$1.ClE_0? $1.ClP_0($3$1.ClE_0):(($4)($1.ClP_0))($2)"
-  const PatIter = "$1.ClP_0($3$1.ClE_0)" # we know the env exists
+  template callIter(rp, params: Snippet): Snippet =
+    # we know the env exists
+    let e = dotField(rp, "ClE_0")
+    let p = dotField(rp, "ClP_0")
+    # note `params` here is actually multiple params
+    if params.len == 0:
+      cCall(p, e)
+    else:
+      cCall(p, params, e)
 
   var op = initLocExpr(p, ri[0])
 
@@ -500,20 +546,23 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
   var typ = skipTypes(ri[0].typ, abstractInstOwned)
   assert(typ.kind == tyProc)
 
-  var pl = newRopeAppender()
-  genParams(p, ri, typ, pl)
+  var params = newBuilder("")
+  var argBuilder = default(CallBuilder) # not initCallBuilder, we just want the params
+  genParams(p, ri, typ, params, argBuilder)
 
   template genCallPattern {.dirty.} =
-    if tfIterator in typ.flags:
-      lineF(p, cpsStmts, PatIter & ";$n", [rdLoc(op), pl, pl.addComma, rawProc])
-    else:
-      lineF(p, cpsStmts, PatProc & ";$n", [rdLoc(op), pl, pl.addComma, rawProc])
+    let rp = rdLoc(op)
+    let pars = extract(params)
+    p.s(cpsStmts).addStmt():
+      if tfIterator in typ.flags:
+        p.s(cpsStmts).add(callIter(rp, pars))
+      else:
+        p.s(cpsStmts).add(callProc(rp, pars, rawProc))
 
   let rawProc = getClosureType(p.module, typ, clHalf)
   let canRaise = p.config.exc == excGoto and canRaiseDisp(p, ri[0])
   if typ.returnType != nil:
     if isInvalidReturnType(p.config, typ):
-      if ri.len > 1: pl.add(", ")
       # beware of 'result = p(result)'. We may need to allocate a temporary:
       if d.k in {locTemp, locNone} or not preventNrvo(p, d.lode, le, ri):
         # Great, we can use 'd':
@@ -522,12 +571,14 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
         elif d.k notin {locTemp} and not hasNoInit(ri):
           # reset before pass as 'result' var:
           discard "resetLoc(p, d)"
-        pl.add(addrLoc(p.config, d))
+        params.addArgument(argBuilder):
+          params.add(addrLoc(p.config, d))
         genCallPattern()
         if canRaise: raiseExit(p)
       else:
         var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
-        pl.add(addrLoc(p.config, tmp))
+        params.addArgument(argBuilder):
+          params.add(addrLoc(p.config, tmp))
         genCallPattern()
         if canRaise: raiseExit(p)
         genAssignment(p, d, tmp, {}) # no need for deep copying
@@ -535,20 +586,24 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
       if d.k == locNone: d = getTemp(p, typ.returnType)
       assert(d.t != nil)        # generate an assignment to d:
       var list: TLoc = initLoc(locCall, d.lode, OnUnknown)
+      let rp = rdLoc(op)
+      let pars = extract(params)
       if tfIterator in typ.flags:
-        list.snippet = PatIter % [rdLoc(op), pl, pl.addComma, rawProc]
+        list.snippet = callIter(rp, pars)
       else:
-        list.snippet = PatProc % [rdLoc(op), pl, pl.addComma, rawProc]
+        list.snippet = callProc(rp, pars, rawProc)
       genAssignment(p, d, list, {}) # no need for deep copying
       if canRaise: raiseExit(p)
     else:
       var tmp: TLoc = getTemp(p, typ.returnType)
       assert(d.t != nil)        # generate an assignment to d:
       var list: TLoc = initLoc(locCall, d.lode, OnUnknown)
+      let rp = rdLoc(op)
+      let pars = extract(params)
       if tfIterator in typ.flags:
-        list.snippet = PatIter % [rdLoc(op), pl, pl.addComma, rawProc]
+        list.snippet = callIter(rp, pars)
       else:
-        list.snippet = PatProc % [rdLoc(op), pl, pl.addComma, rawProc]
+        list.snippet = callProc(rp, pars, rawProc)
       genAssignment(p, tmp, list, {})
       if canRaise: raiseExit(p)
       genAssignment(p, d, tmp, {})
@@ -556,8 +611,8 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
     genCallPattern()
     if canRaise: raiseExit(p)
 
-proc genOtherArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Rope;
-                 argsCounter: var int) =
+proc genOtherArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Builder;
+                 argBuilder: var CallBuilder) =
   if i < typ.n.len:
     # 'var T' is 'T&' in C++. This means we ignore the request of
     # any nkHiddenAddr when it's a 'var T'.
@@ -566,20 +621,17 @@ proc genOtherArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Rope;
     if paramType.typ.isCompileTimeOnly:
       discard
     elif paramType.typ.kind in {tyVar} and ri[i].kind == nkHiddenAddr:
-      if argsCounter > 0: result.add ", "
-      genArgNoParam(p, ri[i][0], result)
-      inc argsCounter
+      result.addArgument(argBuilder):
+        genArgNoParam(p, ri[i][0], result)
     else:
-      if argsCounter > 0: result.add ", "
-      genArgNoParam(p, ri[i], result) #, typ.n[i].sym)
-      inc argsCounter
+      result.addArgument(argBuilder):
+        genArgNoParam(p, ri[i], result) #, typ.n[i].sym)
   else:
     if tfVarargs notin typ.flags:
       localError(p.config, ri.info, "wrong argument count")
     else:
-      if argsCounter > 0: result.add ", "
-      genArgNoParam(p, ri[i], result)
-      inc argsCounter
+      result.addArgument(argBuilder):
+        genArgNoParam(p, ri[i], result)
 
 discard """
 Dot call syntax in C++
@@ -636,7 +688,7 @@ proc skipAddrDeref(node: PNode): PNode =
   else:
     result = node
 
-proc genThisArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Rope) =
+proc genThisArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Builder) =
   # for better or worse c2nim translates the 'this' argument to a 'var T'.
   # However manual wrappers may also use 'ptr T'. In any case we support both
   # for convenience.
@@ -671,15 +723,15 @@ proc genThisArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Rope) =
     genArgNoParam(p, ri, result) #, typ.n[i].sym)
     result.add(".")
 
-proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Rope) =
+proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Builder) =
   var i = 0
   var j = 1
   while i < pat.len:
     case pat[i]
     of '@':
-      var argsCounter = 0
+      var callBuilder = default(CallBuilder) # not init call builder
       for k in j..<ri.len:
-        genOtherArg(p, ri, k, typ, result, argsCounter)
+        genOtherArg(p, ri, k, typ, result, callBuilder)
       inc i
     of '#':
       if i+1 < pat.len and pat[i+1] in {'+', '@'}:
@@ -689,11 +741,11 @@ proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Ro
           if pat[i+1] == '+': genArgNoParam(p, ri[0], result)
           result.add("(")
           if 1 < ri.len:
-            var argsCounterB = 0
-            genOtherArg(p, ri, 1, typ, result, argsCounterB)
+            var callBuilder: CallBuilder = default(CallBuilder)
+            genOtherArg(p, ri, 1, typ, result, callBuilder)
           for k in j+1..<ri.len:
-            var argsCounterB = 0
-            genOtherArg(p, ri, k, typ, result, argsCounterB)
+            var callBuilder: CallBuilder = default(CallBuilder)
+            genOtherArg(p, ri, k, typ, result, callBuilder)
           result.add(")")
         else:
           localError(p.config, ri.info, "call expression expected for C++ pattern")
@@ -707,15 +759,15 @@ proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Ro
         genArgNoParam(p, arg, result)
         #result.add debugTree(arg, 0, 10)
       else:
-        var argsCounter = 0
-        genOtherArg(p, ri, j, typ, result, argsCounter)
+        var callBuilder = default(CallBuilder) # not init call builder
+        genOtherArg(p, ri, j, typ, result, callBuilder)
       inc j
       inc i
     of '\'':
       var idx, stars: int = 0
       if scanCppGenericSlot(pat, i, idx, stars):
         var t = resolveStarsInCppType(typ, idx, stars)
-        if t == nil: result.add("void")
+        if t == nil: result.add(CVoid)
         else: result.add(getTypeDesc(p.module, t))
     else:
       let start = i
@@ -734,7 +786,7 @@ proc genInfixCall(p: BProc, le, ri: PNode, d: var TLoc) =
   let pat = $ri[0].sym.loc.snippet
   internalAssert p.config, pat.len > 0
   if pat.contains({'#', '(', '@', '\''}):
-    var pl = newRopeAppender()
+    var pl = newBuilder("")
     genPatternCall(p, ri, pat, typ, pl)
     # simpler version of 'fixupCall' that works with the pl+params combination:
     var typ = skipTypes(ri[0].typ, abstractInst)
@@ -744,32 +796,32 @@ proc genInfixCall(p: BProc, le, ri: PNode, d: var TLoc) =
         # with them to prevent undefined behaviour and because the codegen
         # is free to emit expressions multiple times!
         d.k = locCall
-        d.snippet = pl
+        d.snippet = extract(pl)
         excl d.flags, lfSingleUse
       else:
         if d.k == locNone: d = getTemp(p, typ.returnType)
         assert(d.t != nil)        # generate an assignment to d:
         var list: TLoc = initLoc(locCall, d.lode, OnUnknown)
-        list.snippet = pl
+        list.snippet = extract(pl)
         genAssignment(p, d, list, {}) # no need for deep copying
     else:
-      pl.add(";\n")
-      line(p, cpsStmts, pl)
+      p.s(cpsStmts).addStmt():
+        p.s(cpsStmts).add(extract(pl))
   else:
-    var pl = newRopeAppender()
-    var argsCounter = 0
+    var pl = newBuilder("")
     if 1 < ri.len:
       genThisArg(p, ri, 1, typ, pl)
     pl.add(op.snippet)
-    var params = newRopeAppender()
+    var res = newBuilder("")
+    var call = initCallBuilder(res, extract(pl))
     for i in 2..<ri.len:
-      genOtherArg(p, ri, i, typ, params, argsCounter)
-    fixupCall(p, le, ri, d, pl, params)
+      genOtherArg(p, ri, i, typ, res, call)
+    fixupCall(p, le, ri, d, res, call)
 
 proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) =
   # generates a crappy ObjC call
   var op = initLocExpr(p, ri[0])
-  var pl = "["
+  var pl = newBuilder("[")
   # getUniqueType() is too expensive here:
   var typ = skipTypes(ri[0].typ, abstractInst)
   assert(typ.kind == tyProc)
@@ -811,24 +863,27 @@ proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) =
         if d.k == locNone: d = getTemp(p, typ.returnType, needsInit=true)
         pl.add("Result: ")
         pl.add(addrLoc(p.config, d))
-        pl.add("];\n")
-        line(p, cpsStmts, pl)
+        pl.add("]")
+        p.s(cpsStmts).addStmt():
+          p.s(cpsStmts).add(extract(pl))
       else:
         var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
         pl.add(addrLoc(p.config, tmp))
-        pl.add("];\n")
-        line(p, cpsStmts, pl)
+        pl.add("]")
+        p.s(cpsStmts).addStmt():
+          p.s(cpsStmts).add(extract(pl))
         genAssignment(p, d, tmp, {}) # no need for deep copying
     else:
       pl.add("]")
       if d.k == locNone: d = getTemp(p, typ.returnType)
       assert(d.t != nil)        # generate an assignment to d:
       var list: TLoc = initLoc(locCall, ri, OnUnknown)
-      list.snippet = pl
+      list.snippet = extract(pl)
       genAssignment(p, d, list, {}) # no need for deep copying
   else:
-    pl.add("];\n")
-    line(p, cpsStmts, pl)
+    pl.add("]")
+    p.s(cpsStmts).addStmt():
+      p.s(cpsStmts).add(extract(pl))
 
 proc notYetAlive(n: PNode): bool {.inline.} =
   let r = getRoot(n)

compiler/ccgliterals.nim

@@ -36,52 +36,84 @@ 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 = NimChar, len = s.len + 1)
+  do:
+    var strInit: StructInitializer
+    res.addStructInitializer(strInit, kind = siOrderedStruct):
+      res.addField(strInit, name = "Sup"):
+        var seqInit: StructInitializer
+        res.addStructInitializer(seqInit, kind = siOrderedStruct):
+          res.addField(seqInit, name = "len"):
+            res.addIntValue(s.len)
+          res.addField(seqInit, name = "reserved"):
+            res.add(cCast(NimInt, cOp(BitOr, NimUint, cCast(NimUint, cIntValue(s.len)), NimStrlitFlag)))
+      res.addField(strInit, name = "data"):
+        res.add(makeCString(s))
+  m.s[cfsStrData].add(extract(res))
 
-proc genStringLiteralV1(m: BModule; n: PNode; result: var Rope) =
+proc genStringLiteralV1(m: BModule; n: PNode; result: var Builder) =
   if s.isNil:
-    appcg(m, result, "((#NimStringDesc*) NIM_NIL)", [])
+    result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), NimNil))
   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 = NimInt)
+      res.addArrayField(name = "data", elementType = NimChar, len = s.len + 1)
+  do:
+    var structInit: StructInitializer
+    res.addStructInitializer(structInit, kind = siOrderedStruct):
+      res.addField(structInit, name = "cap"):
+        res.add(cOp(BitOr, NimInt, cIntValue(s.len), NimStrlitFlag))
+      res.addField(structInit, name = "data"):
+        res.add(makeCString(s))
+  m.s[cfsStrData].add(extract(res))
 
-proc genStringLiteralV2(m: BModule; n: PNode; isConst: bool; result: var Rope) =
+proc genStringLiteralV2(m: BModule; n: PNode; isConst: bool; result: var Builder) =
   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.addVarWithInitializer(
+      if isConst: AlwaysConst else: Global,
+      name = tmp,
+      typ = "NimStringV2"):
+    var strInit: StructInitializer
+    res.addStructInitializer(strInit, kind = siOrderedStruct):
+      res.addField(strInit, name = "len"):
+        res.addIntValue(n.strVal.len)
+      res.addField(strInit, name = "p"):
+        res.add(cCast(ptrType("NimStrPayload"), cAddr(litName)))
+  m.s[cfsStrData].add(extract(res))
 
-proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Rope) =
+proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Builder) =
   let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
   var pureLit: Rope
   if id == m.labels:
@@ -92,7 +124,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.addIntValue(n.strVal.len)
+    result.addField(strInit, name = "p"):
+      result.add(cCast(ptrType("NimStrPayload"), cAddr(pureLit)))
 
 # ------ Version selector ---------------------------------------------------
 
@@ -107,10 +144,10 @@ proc genStringLiteralDataOnly(m: BModule; s: string; info: TLineInfo;
   else:
     localError(m.config, info, "cannot determine how to produce code for string literal")
 
-proc genNilStringLiteral(m: BModule; info: TLineInfo; result: var Rope) =
-  appcg(m, result, "((#NimStringDesc*) NIM_NIL)", [])
+proc genNilStringLiteral(m: BModule; info: TLineInfo; result: var Builder) =
+  result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), NimNil))
 
-proc genStringLiteral(m: BModule; n: PNode; result: var Rope) =
+proc genStringLiteral(m: BModule; n: PNode; result: var Builder) =
   case detectStrVersion(m)
   of 0, 1: genStringLiteralV1(m, n, result)
   of 2: genStringLiteralV2(m, n, isConst = true, result)

compiler/ccgreset.nim

@@ -27,25 +27,28 @@ proc specializeResetN(p: BProc, accessor: Rope, n: PNode;
     if disc.loc.snippet == "": fillObjectFields(p.module, typ)
     if disc.loc.t == nil:
       internalError(p.config, n.info, "specializeResetN()")
-    lineF(p, cpsStmts, "switch ($1.$2) {$n", [accessor, disc.loc.snippet])
-    for i in 1..<n.len:
-      let branch = n[i]
-      assert branch.kind in {nkOfBranch, nkElse}
-      if branch.kind == nkOfBranch:
-        genCaseRange(p, branch)
-      else:
-        lineF(p, cpsStmts, "default:$n", [])
-      specializeResetN(p, accessor, lastSon(branch), typ)
-      lineF(p, cpsStmts, "break;$n", [])
-    lineF(p, cpsStmts, "} $n", [])
-    specializeResetT(p, "$1.$2" % [accessor, disc.loc.snippet], disc.loc.t)
+    let discField = dotField(accessor, disc.loc.snippet)
+    p.s(cpsStmts).addSwitchStmt(discField):
+      for i in 1..<n.len:
+        let branch = n[i]
+        assert branch.kind in {nkOfBranch, nkElse}
+        var caseBuilder: SwitchCaseBuilder
+        p.s(cpsStmts).addSwitchCase(caseBuilder):
+          if branch.kind == nkOfBranch:
+            genCaseRange(p, branch, caseBuilder)
+          else:
+            p.s(cpsStmts).addCaseElse(caseBuilder)
+        do:
+          specializeResetN(p, accessor, lastSon(branch), typ)
+          p.s(cpsStmts).addBreak()
+    specializeResetT(p, discField, disc.loc.t)
   of nkSym:
     let field = n.sym
     if field.typ.kind == tyVoid: return
     if field.loc.snippet == "": fillObjectFields(p.module, typ)
     if field.loc.t == nil:
       internalError(p.config, n.info, "specializeResetN()")
-    specializeResetT(p, "$1.$2" % [accessor, field.loc.snippet], field.loc.t)
+    specializeResetT(p, dotField(accessor, field.loc.snippet), field.loc.t)
   else: internalError(p.config, n.info, "specializeResetN()")
 
 proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
@@ -58,62 +61,44 @@ proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
   of tyArray:
     let arraySize = lengthOrd(p.config, typ.indexType)
     var i: TLoc = getTemp(p, getSysType(p.module.g.graph, unknownLineInfo, tyInt))
-    linefmt(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n",
-            [i.snippet, arraySize])
-    specializeResetT(p, ropecg(p.module, "$1[$2]", [accessor, i.snippet]), typ.elementType)
-    lineF(p, cpsStmts, "}$n", [])
+    p.s(cpsStmts).addForRangeExclusive(i.snippet, cIntValue(0), cIntValue(arraySize)):
+      specializeResetT(p, subscript(accessor, i.snippet), typ.elementType)
   of tyObject:
     var x = typ.baseClass
     if x != nil: x = x.skipTypes(skipPtrs)
     specializeResetT(p, accessor.parentObj(p.module), x)
-    if typ.n != nil:
-      if typ.sym != nil and sfImportc in typ.sym.flags:
-        # imported C struct, nimZeroMem
-        lineCg(p, cpsStmts, "#nimZeroMem((void**)&$1, sizeof($2));$n",
-            [accessor, getTypeDesc(p.module, typ)])
-      else:
-        specializeResetN(p, accessor, typ.n, typ)
-        if isCaseObj(typ.n):
-          # The active branch was released above. Clear the complete object so
-          # stale bytes from overlapping branches cannot be traced by the GC.
-          # type
-          #   Foo = object
-          #     case kind: bool
-          #     of true:
-          #       a: ref Bar   # 8 bytes (pointer)
-          #     of false:
-          #       b: int       # 4 bytes
-          # specializeResetT for b emits accessor.b = 0 — writes 4 bytes
-          # But the union is 8 bytes wide (sized by the largest branch)
-          # The remaining 4 bytes where a used to live are untouched
-          # Those stale bytes could contain a heap pointer the GC traces → crash
-          lineCg(p, cpsStmts, "#nimZeroMem((void**)&$1, sizeof($2));$n",
-                 [accessor, getTypeDesc(p.module, typ)])
+    if typ.n != nil: specializeResetN(p, accessor, typ.n, typ)
   of tyTuple:
     let typ = getUniqueType(typ)
     for i, a in typ.ikids:
-      specializeResetT(p, ropecg(p.module, "$1.Field$2", [accessor, i]), a)
+      specializeResetT(p, dotField(accessor, "Field" & $i), a)
 
   of tyString, tyRef, tySequence:
-    lineCg(p, cpsStmts, "#unsureAsgnRef((void**)&$1, NIM_NIL);$n", [accessor])
+    p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "unsureAsgnRef"),
+      cCast(ptrType(CPointer), cAddr(accessor)),
+      NimNil)
 
   of tyProc:
     if typ.callConv == ccClosure:
-      lineCg(p, cpsStmts, "#unsureAsgnRef((void**)&$1.ClE_0, NIM_NIL);$n", [accessor])
-      lineCg(p, cpsStmts, "$1.ClP_0 = NIM_NIL;$n", [accessor])
+      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "unsureAsgnRef"),
+        cCast(ptrType(CPointer), cAddr(dotField(accessor, "ClE_0"))),
+        NimNil)
+      p.s(cpsStmts).addFieldAssignment(accessor, "ClP_0", NimNil)
     else:
-      lineCg(p, cpsStmts, "$1 = NIM_NIL;$n", [accessor])
+      p.s(cpsStmts).addAssignment(accessor, NimNil)
   of tyChar, tyBool, tyEnum, tyRange, tyInt..tyUInt64:
-    lineCg(p, cpsStmts, "$1 = 0;$n", [accessor])
+    p.s(cpsStmts).addAssignment(accessor, cIntValue(0))
   of tyCstring, tyPointer, tyPtr, tyVar, tyLent:
-    lineCg(p, cpsStmts, "$1 = NIM_NIL;$n", [accessor])
+    p.s(cpsStmts).addAssignment(accessor, NimNil)
   of tySet:
     case mapSetType(p.config, typ)
     of ctArray:
-      lineCg(p, cpsStmts, "#nimZeroMem($1, sizeof($2));$n",
-          [accessor, getTypeDesc(p.module, typ)])
+      let t = getTypeDesc(p.module, typ)
+      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimZeroMem"),
+        accessor,
+        cSizeof(t))
     of ctInt8, ctInt16, ctInt32, ctInt64:
-      lineCg(p, cpsStmts, "$1 = 0;$n", [accessor])
+      p.s(cpsStmts).addAssignment(accessor, cIntValue(0))
     else:
       raiseAssert "unexpected set type kind"
   of tyNone, tyEmpty, tyNil, tyUntyped, tyTyped, tyGenericInvocation,

compiler/ccgthreadvars.nim

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

compiler/ccgtrav.nim

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

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

@@ -11,7 +11,7 @@
 
 import
   ast, ropes, options,
-  lineinfos, pathutils, modulegraphs
+  lineinfos, pathutils, modulegraphs, cbuilderbase
 
 import std/[intsets, tables, sets]
 
@@ -43,12 +43,12 @@ type
     ctUInt, ctUInt8, ctUInt16, ctUInt32, ctUInt64,
     ctArray, ctPtrToArray, ctStruct, ctPtr, ctNimStr, ctNimSeq, ctProc,
     ctCString
-  TCFileSections* = array[TCFileSection, Rope] # represents a generated C file
+  TCFileSections* = array[TCFileSection, Builder] # represents a generated C file
   TCProcSection* = enum       # the sections a generated C proc consists of
     cpsLocals,                # section of local variables for C proc
     cpsInit,                  # section for init of variables for C proc
     cpsStmts                  # section of local statements for C proc
-  TCProcSections* = array[TCProcSection, Rope] # represents a generated C proc
+  TCProcSections* = array[TCProcSection, Builder] # represents a generated C proc
   BModule* = ref TCGen
   BProc* = ref TCProc
   TBlock* = object
@@ -75,13 +75,10 @@ type
     flags*: set[TCProcFlag]
     lastLineInfo*: TLineInfo  # to avoid generating excessive 'nimln' statements
     currLineInfo*: TLineInfo  # AST codegen will make this superfluous
-    nestedTryStmts*: seq[tuple[fin: PNode, inExcept: bool, isHidden: bool, label: Natural]]
+    nestedTryStmts*: seq[tuple[fin: PNode, inExcept: bool, label: Natural]]
                               # in how many nested try statements we are
                               # (the vars must be volatile then)
-                              # `inExcept` is true when we are in the except part of a try block.
-                              # `isHidden` is true for compiler-injected `nkHiddenTryStmt` wrappers
-                              # (e.g. ARC's destructor try/finally around `except T as e:` bodies);
-                              # finallyActions walks past such wrappers to reach the user's try.
+                              # bool is true when are in the except part of a try block
     finallySafePoints*: seq[Rope]  # For correctly cleaning up exceptions when
                                    # using return in finally statements
     labels*: Natural          # for generating unique labels in the C proc
@@ -118,7 +115,7 @@ type
                         # computing alive data on our own.
 
   BModuleList* = ref object of RootObj
-    mainModProcs*, mainModInit*, otherModsInit*, mainDatInit*: Rope
+    mainModProcs*, mainModInit*, otherModsInit*, mainDatInit*: Builder
     mapping*: Rope             # the generated mapping file (if requested)
     modules*: seq[BModule]     # list of all compiled modules
     modulesClosed*: seq[BModule] # list of the same compiled modules, but in the order they were closed
@@ -130,7 +127,7 @@ type
     graph*: ModuleGraph
     strVersion*, seqVersion*: int # version of the string/seq implementation to use
 
-    nimtv*: Rope            # Nim thread vars; the struct body
+    nimtv*: Builder         # Nim thread vars; the struct body
     nimtvDeps*: seq[PType]  # type deps: every module needs whole struct
     nimtvDeclared*: IntSet  # so that every var/field exists only once
                             # in the struct
@@ -164,14 +161,15 @@ type
     typeInfoMarkerV2*: TypeCache
     initProc*: BProc          # code for init procedure
     preInitProc*: BProc       # code executed before the init proc
-    hcrCreateTypeInfosProc*: Rope # type info globals are in here when HCR=on
+    hcrCreateTypeInfosProc*: Builder # type info globals are in here when HCR=on
     inHcrInitGuard*: bool     # We are currently within a HCR reloading guard.
+    hcrInitGuard*: IfBuilder
     typeStack*: TTypeSeq      # used for type generation
     dataCache*: TNodeTable
     typeNodes*, nimTypes*: int # used for type info generation
     typeNodesName*, nimTypesName*: Rope # used for type info generation
     labels*: Natural          # for generating unique module-scope names
-    extensionLoaders*: array['0'..'9', Rope] # special procs for the
+    extensionLoaders*: array['0'..'9', Builder] # special procs for the
                                              # OpenGL wrapper
     sigConflicts*: CountTable[SigHash]
     g*: BModuleList
@@ -184,18 +182,18 @@ proc includeHeader*(this: BModule; header: string) =
   if not this.headerFiles.contains header:
     this.headerFiles.add header
 
-proc s*(p: BProc, s: TCProcSection): var Rope {.inline.} =
+proc s*(p: BProc, s: TCProcSection): var Builder {.inline.} =
   # section in the current block
   result = p.blocks[^1].sections[s]
 
-proc procSec*(p: BProc, s: TCProcSection): var Rope {.inline.} =
+proc procSec*(p: BProc, s: TCProcSection): var Builder {.inline.} =
   # top level proc sections
   result = p.blocks[0].sections[s]
 
 proc initBlock*(): TBlock =
   result = TBlock()
   for i in low(result.sections)..high(result.sections):
-    result.sections[i] = newRopeAppender()
+    result.sections[i] = newBuilder("")
 
 proc newProc*(prc: PSym, module: BModule): BProc =
   result = BProc(

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 % "-")
@@ -364,7 +364,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 +459,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 +760,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
@@ -784,7 +775,6 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
   of "hotcodereloading":
     processOnOffSwitchG(conf, {optHotCodeReloading}, arg, pass, info)
     if conf.hcrOn:
-      warningDeprecated(conf, info, "hotCodeReloading is deprecated, see https://github.com/nim-lang/RFCs/issues/573 for further information")
       defineSymbol(conf.symbols, "hotcodereloading")
       defineSymbol(conf.symbols, "useNimRtl")
       # hardcoded linking with dynamic runtime for MSVC for smaller binaries
@@ -892,19 +882,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(if arg.startsWith(stdPrefix): arg else: 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":
@@ -936,7 +918,7 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
     expectArg(conf, switch, arg, pass, info)
     var value: int = 10_000_000
     discard parseSaturatedNatural(arg, value)
-    if value <= 0: localError(conf, info, "maxLoopIterationsVM must be a positive integer greater than zero")
+    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)
@@ -953,10 +935,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)
@@ -1098,9 +1076,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
@@ -1132,10 +1107,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

@@ -11,16 +11,15 @@
 ## for details. Note this is a first implementation and only the "Concept matching"
 ## section has been implemented.
 
-import ast, semdata, lookups, lineinfos, idents, msgs, renderer, types,
-  layeredtable, semtypinst
+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
 ## --------------------------------------
@@ -71,90 +70,26 @@ proc semConceptDeclaration*(c: PContext; n: PNode): PNode =
 ## ----------------
 
 type
-  MatchFlags* = enum
-    mfDontBind  # Do not export bindings from the concept match
-    mfBindGenericParam  # Export inferred invocation parameters despite mfDontBind
-    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
+    concpt: PType
 
 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 matchType(c: PContext; f, ao: PType; m: var MatchCon): bool
 
 proc acceptsAllTypes(t: PType): bool=
   result = false
@@ -166,187 +101,84 @@ proc acceptsAllTypes(t: PType): bool=
     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}):
+  for i in start..<f.kidsLen - ord(f.kind == tyGenericInst):
     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, ao: 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.
+  const
+    ignorableForArgType = {tyVar, tySink, tyLent, tyOwned, tyGenericInst, tyAlias, tyInferred}
   
-  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
+  var a = ao
   
-  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)
+  case a.kind
+  of tyGenericParam:
+    let binding = m.existingBinding(a)
+    if binding != nil:
+      a = binding
+  else:
+    discard
   
-  result = false
-
   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}:
+        result = false
         if m.potentialImplementation.reduceToBase.kind in arrPutGetMagicApplies:
-          bindParam(c, m, a, last m.potentialImplementation)
+          m.inferred.add((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)
+        result = matchType(c, a, m.potentialImplementation, m)
     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:
+        result = matchKids(c, f, a, m, start=FirstGenericParamAt)
+  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, " ", last 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.
@@ -354,59 +186,91 @@ 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:
+       (ak.kind == tyGenericParam and ak.hasElementType and ak.elementType.kind == tyOrdinal)
+  of tyConcept:
+    if a.kind == tyConcept and f.n == a.n:
+      result = true
+    elif m.concpt.size == szIllegalRecursion:
+      result = false
+    else:
+      let oldLen = m.inferred.len
+      let oldPotentialImplementation = m.potentialImplementation
+      m.potentialImplementation = a
+      m.concpt.size = szIllegalRecursion
+      let oldConcept = m.concpt
+      m.concpt = f
+      result = conceptMatchNode(c, f.n.lastSon, m)
+      m.potentialImplementation = oldPotentialImplementation
+      m.concpt = oldConcept
+      m.concpt.size = szUnknownSize
+      if not result:
+        m.inferred.setLen oldLen
+  of tyGenericBody:
+    var ak = a
+    if a.kind == tyGenericBody:
+      ak = last(a)
+    result = matchType(c, last(f), ak, m)
+  of tyCompositeTypeClass:
+    var ak = if a.kind == tyCompositeTypeClass: a.last else: a
+    result = matchType(c, last(f), ak, m)
+  of tyArray, tyTuple, tyVarargs, tyOpenArray, tyRange, tySequence, tyRef, tyPtr,
+     tyGenericInst:
+    # ^ XXX Rewrite this logic, it's more complex than it needs to be.
+    if f.kind == tyArray and f.kidsLen == 3:
       # XXX: this is a work-around!
       # system.nim creates these for the magic array typeclass
       result = true
     else:
+      result = false
       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:
-    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
+      if ak.kind == f.kind and f.kidsLen == ak.kidsLen:
+        result = matchKids(c, f, ak, m)
+  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 f.kids:
+        for aa in a.kids:
+          let oldLenB = m.inferred.len
+          let r = matchType(c, ff, aa, m)
+          if r:
+            inc covered
             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)
+          m.inferred.setLen oldLenB
+
+      result = covered >= a.kidsLen
+      if not result:
+        m.inferred.setLen oldLen
+    else:
+      result = false
+      for ff in f.kids:
+        result = matchType(c, ff, a, m)
+        if result: break # and remember the binding!
+        m.inferred.setLen oldLen
+  of tyNot:
+    if a.kind == tyNot:
+      result = matchType(c, f.elementType, a.elementType, m)
+    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
   of tyStatic:
+    result = false
     var scomp = f.base
     if scomp.kind == tyGenericParam:
       if f.base.kidsLen > 0:
@@ -415,75 +279,8 @@ proc matchType(c: PContext; fo, ao: PType; m: var MatchCon): bool =
       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
-  of tyOr:
-    if a.kind == tyOr:
-      var covered = 0
-      for ff in traverseTyOr(f):
-        for aa in traverseTyOr(a):
-          m.bindings = m.bindings.newTypeMapLayer()
-          let r = matchType(c, ff, aa, m)
-          if r:
-            inc covered
-            break
-          m.bindings.setToPreviousLayer()
-
-      result = covered >= a.kidsLen
-    else:
-      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:
-      result = matchType(c, f.elementType, a.elementType, m)
   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
@@ -493,38 +290,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:
@@ -532,7 +321,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
@@ -540,14 +329,13 @@ 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)
   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'
@@ -580,76 +368,7 @@ proc conceptMatchNode(c: PContext; n: PNode; m: var MatchCon): bool =
     # error was reported earlier.
     result = false
 
-proc resolvedBinding(c: PContext; t: PType; m: MatchCon): PType =
-  ## An inferred concept parameter can refer to an implementation-local
-  ## generic parameter, for example `Elem[Impl.T]`. Resolve it while the
-  ## matcher's private bindings (`Impl.T -> int`) are still available.
-  if t.containsUnresolvedType:
-    prepareMetatypeForSigmatch(c, m.bindings, m.concpt.sym.info, t)
-  else:
-    t
-
-proc fixBindings(c: PContext; 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:
-        let resolved = resolvedBinding(c, found, m)
-        when logBindings: echo "Invocation bind: ", thisSym, " ", resolved
-        bindings.put(thisSym, resolved)
-    
-    # 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 fixConstraintBindings(c: PContext; bindings: var LayeredIdTable;
-                           invocation: PType; m: MatchCon) =
-  ## Propagates only the dependent parameters of a concept constraint. The
-  ## concept itself and its private matcher bindings must remain unbound so
-  ## that independent constraints using the same concept don't get coupled.
-  if invocation != nil and invocation.kind == tyGenericInvocation:
-    let genBody = invocation.base
-    assert genBody.kind == tyGenericBody
-    for i in FirstGenericParamAt ..< invocation.kidsLen:
-      if lookup(bindings, invocation[i]) == nil:
-        let boundValue = m.bindings.lookup(genBody[i - 1])
-        if boundValue != nil:
-          bindings.put(invocation[i], resolvedBinding(c, boundValue, m))
-
-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:
-    if mfDontBind notin m.flags:
-      fixBindings(c, bindings, concpt, invocation, m)
-    elif mfBindGenericParam in m.flags:
-      fixConstraintBindings(c, bindings, 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
@@ -658,16 +377,28 @@ 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)
-
-  
+  if arg.containsUnresolvedType:
+    return false
+  var m = MatchCon(inferred: @[], potentialImplementation: arg, concpt: concpt)
+  result = conceptMatchNode(c, concpt.n.lastSon, m)
+  if result:
+    for (a, b) in m.inferred:
+      if b.kind == tyGenericParam:
+        var dest = b
+        while true:
+          dest = existingBinding(m, dest)
+          if dest == nil or dest.kind != tyGenericParam: break
+        if dest != nil:
+          bindings.put(a, dest)
+          when logBindings: echo "A bind ", a, " ", dest
+      else:
+        bindings.put(a, b)
+        when logBindings: echo "B bind ", a, " ", b
+    # we have a match, so bind 'arg' itself to 'concpt':
+    bindings.put(concpt, arg)
+    # invocation != nil means we have a non-atomic concept:
+    if invocation != nil and arg.kind == tyGenericInst and invocation.kidsLen == arg.kidsLen-1:
+      # bind even more generic parameters
+      assert invocation.kind == tyGenericInvocation
+      for i in FirstGenericParamAt ..< invocation.kidsLen:
+        bindings.put(invocation[i], arg[i])

compiler/condsyms.nim

@@ -159,7 +159,7 @@ proc initDefines*(symbols: StringTableRef) =
   defineSymbol("nimHasEnsureMove")
   defineSymbol("nimHasNoReturnError")
 
-  defineSymbol("nimUseStrictDefs")
+  defineSymbol("nimUseStrictDefs") # deadcode
   defineSymbol("nimHasNolineTooLong")
 
   defineSymbol("nimHasCastExtendedVm")
@@ -172,7 +172,3 @@ proc initDefines*(symbols: StringTableRef) =
   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)
@@ -454,7 +454,7 @@ proc gen(c: var Con; n: PNode) =
   of nkPragmaBlock: gen(c, n.lastSon)
   of nkDiscardStmt, nkObjDownConv, nkObjUpConv, nkStringToCString, nkCStringToString:
     gen(c, n[0])
-  of nkConv, nkExprColonExpr, nkExprEqExpr, PathKinds1:
+  of nkConv, nkExprColonExpr, nkExprEqExpr, nkCast, PathKinds1:
     gen(c, n[1])
   of nkVarSection, nkLetSection: genVarSection(c, n)
   of nkDefer: raiseAssert "dfa construction pass requires the elimination of 'defer'"

compiler/docgen.nim

@@ -148,7 +148,7 @@ proc cmpDecimalsIgnoreCase(a, b: string): int =
         limitB = iB
       while limitA < aLen and isDigit(a[limitA]): inc limitA
       while limitB < bLen and isDigit(b[limitB]): inc limitB
-      var pos = max(limitA-iA, limitB-iB)
+      var pos = max(limitA-iA, limitB-iA)
       while pos > 0:
         if limitA-pos < iA:  # digit in `a` is 0 effectively
           result = ord('0') - ord(b[limitB-pos])
@@ -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,
@@ -540,11 +537,10 @@ proc nodeToHighlightedHtml(d: PDoc; n: PNode; result: var string;
       elif s != nil and s.kind in {skType, skVar, skLet, skConst} and
            sfExported in s.flags and s.owner != nil and
            belongsToProjectPackage(d.conf, s.owner) and d.target == outHtml:
-        let href = (if d.module == s.owner: ""
-            else: externalDep(d, s.owner).changeFileExt("html")
-          ) & "#" & literal
-        result.addf "<a href=\"$1\"><span class=\"Identifier\">$2</span></a>",
-            [href, escLit]
+        let external = externalDep(d, s.owner)
+        result.addf "<a href=\"$1#$2\"><span class=\"Identifier\">$3</span></a>",
+          [changeFileExt(external, "html"), literal,
+           escLit]
       else:
         dispA(d.conf, result, "<span class=\"Identifier\">$1</span>",
               "\\spanIdentifier{$1}", [escLit])
@@ -1180,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:
@@ -1414,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
@@ -1900,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:
@@ -1923,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/guards.nim

@@ -46,7 +46,7 @@ proc isLocation(n: PNode): bool = not n.isValue
 
 proc isLet(n: PNode): bool =
   if n.kind == nkSym:
-    if n.sym.kind in {skLet, skConst, skTemp, skForVar}: # guard immutable variables
+    if n.sym.kind in {skLet, skTemp, skForVar}:
       result = true
     elif n.sym.kind == skParam and skipTypes(n.sym.typ,
                                              abstractInst).kind notin {tyVar}:

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

@@ -13,7 +13,7 @@ import
   ast, astalgo, msgs, options, idents, lookups,
   semdata, modulepaths, sigmatch, lineinfos,
   modulegraphs, wordrecg
-from std/strutils import `%`, startsWith, replace
+from std/strutils import `%`, startsWith
 from std/sequtils import addUnique
 import std/[sets, tables, intsets]
 
@@ -307,9 +307,9 @@ proc myImportModule(c: PContext, n: var PNode, importStmtResult: PNode): PSym =
       var prefix = ""
       if realModule.constraint != nil: prefix = realModule.constraint.strVal & "; "
       message(c.config, n.info, warnDeprecated, prefix & realModule.name.s & " is deprecated")
-    let moduleNameNorm = getModuleName(c.config, n).replace("\\", "/")
-    if belongsToStdlib(c.graph, result) and not startsWith(moduleNameNorm, stdPrefix) and
-        not startsWith(moduleNameNorm, "system/") and not startsWith(moduleNameNorm, "packages/"):
+    let moduleName = getModuleName(c.config, n)
+    if belongsToStdlib(c.graph, result) and not startsWith(moduleName, stdPrefix) and
+        not startsWith(moduleName, "system/") and not startsWith(moduleName, "packages/"):
       message(c.config, n.info, warnStdPrefix, realModule.name.s)
 
     proc suggestMod(n: PNode; s: PSym) =

compiler/injectdestructors.nim

@@ -24,7 +24,7 @@ import std/[strtabs, tables, strutils, intsets]
 when defined(nimPreviewSlimSystem):
   import std/assertions
 
-from trees import exprStructuralEquivalent, getRoot, isCursor, whichPragma
+from trees import exprStructuralEquivalent, getRoot, whichPragma
 
 type
   Con = object
@@ -72,11 +72,9 @@ proc hasDestructor(c: Con; t: PType): bool {.inline.} =
     if not result and c.graph.config.selectedGC in {gcArc, gcOrc, gcAtomicArc}:
       assert(not containsGarbageCollectedRef(t))
 
-proc getTemp(c: var Con; s: var Scope; typ: PType; info: TLineInfo; needsInit: bool): PNode =
+proc getTemp(c: var Con; s: var Scope; typ: PType; info: TLineInfo): PNode =
   let sym = newSym(skTemp, getIdent(c.graph.cache, ":tmpD"), c.idgen, c.owner, info)
   sym.typ = typ
-  if not needsInit:
-    sym.flags.incl sfNoInit
   s.vars.add(sym)
   result = newSymNode(sym)
 
@@ -102,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:
@@ -165,26 +162,33 @@ 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)
   result = nfFirstWrite in m.flags
 
-template isFullyUnpackedTuple(n: PNode): bool =
+proc isCursor(n: PNode): bool =
+  case n.kind
+  of nkSym:
+    sfCursor in n.sym.flags
+  of nkDotExpr:
+    isCursor(n[1])
+  of nkCheckedFieldExpr:
+    isCursor(n[0])
+  else:
+    false
+
+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)
 
@@ -193,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 '\''
@@ -244,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 =
@@ -277,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
@@ -293,7 +291,7 @@ proc genSink(c: var Con; s: var Scope; dest, ri: PNode; flags: set[MoveOrCopyFla
       if deepAliases(dest, ri):
         # consider: x = x + y, it is wrong to destroy the destination first!
         # tmp to support self assignments
-        let tmp = c.getTemp(s, dest.typ, dest.info, needsInit = false)
+        let tmp = c.getTemp(s, dest.typ, dest.info)
         result = newTree(nkStmtList, newTree(nkFastAsgn, tmp, dest), newTree(nkFastAsgn, dest, ri),
                          c.genDestroy(tmp))
       else:
@@ -362,7 +360,7 @@ proc genDiscriminantAsgn(c: var Con; s: var Scope; n: PNode): PNode =
   # but fields within active case branch might need destruction
 
   # tmp to support self assignments
-  let tmp = c.getTemp(s, n[1].typ, n.info, needsInit = false)
+  let tmp = c.getTemp(s, n[1].typ, n.info)
 
   result = newTree(nkStmtList)
   result.add newTree(nkFastAsgn, tmp, p(n[1], c, s, consumed))
@@ -402,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 & ")")
@@ -412,20 +410,6 @@ proc genDefaultCall(t: PType; c: Con; info: TLineInfo): PNode =
   result.add(newSymNode(createMagic(c.graph, c.idgen, "default", mDefault)))
   result.typ() = t
 
-proc stabilizeBracketIndex(n: PNode; c: var Con; body: var PNode): PNode =
-  ## Evaluate a side-effecting index once and return the stable access.
-  doAssert n.kind == nkBracketExpr and not isAtom(n[1])
-  let temp = newSym(skLet, getIdent(c.graph.cache, "bracketTmp"), c.idgen,
-                    c.owner, n[1].info)
-  temp.typ = n[1].typ
-  let tempAsNode = newSymNode(temp)
-  body.add newTree(nkLetSection, n[1].info,
-                   newTree(nkIdentDefs, tempAsNode,
-                           newNodeI(nkEmpty, tempAsNode.info), n[1]))
-  result = copyNode(n)
-  result.add n[0]
-  result.add tempAsNode
-
 proc destructiveMoveVar(n: PNode; c: var Con; s: var Scope): PNode =
   # generate: (let tmp = v; reset(v); tmp)
   if (not hasDestructor(c, n.typ)) and c.inEnsureMove == 0:
@@ -437,10 +421,6 @@ proc destructiveMoveVar(n: PNode; c: var Con; s: var Scope): PNode =
   else:
     result = newNodeIT(nkStmtListExpr, n.info, n.typ)
 
-    var n = n
-    if n.kind == nkBracketExpr and not isAtom(n[1]):
-      n = stabilizeBracketIndex(n, c, result)
-
     var temp = newSym(skLet, getIdent(c.graph.cache, "blitTmp"), c.idgen, c.owner, n.info)
     temp.typ = n.typ
     var v = newNodeI(nkLetSection, n.info)
@@ -466,50 +446,49 @@ proc isCapturedVar(n: PNode): bool =
   else: result = false
 
 proc passCopyToSink(n: PNode; c: var Con; s: var Scope): PNode =
+  result = newNodeIT(nkStmtListExpr, n.info, n.typ)
   let nTyp = n.typ.skipTypes(tyUserTypeClasses)
-  if not hasDestructorOrAsgn(c, nTyp):
-    # Non-managed (plain-old-data) type: no ownership transfer is needed.
-    # Return the expression directly — no temp required.
+  let tmp = c.getTemp(s, nTyp, n.info)
+  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:
+      if sfError in op.flags:
+        c.checkForErrorPragma(nTyp, n, "=dup")
+      else:
+        let copyOp = getAttachedOp(c.graph, typ, attachedAsgn)
+        if copyOp != nil and sfError in copyOp.flags and
+           sfOverridden notin op.flags:
+          c.checkForErrorPragma(nTyp, n, "=dup", inferredFromCopy = true)
+
+      let src = p(n, c, s, normal)
+      var newCall = newTreeIT(nkCall, src.info, src.typ,
+            newSymNode(op),
+            src)
+      c.finishCopy(newCall, n, {}, isFromSink = true)
+      result.add newTreeI(nkFastAsgn,
+          src.info, tmp,
+          newCall
+      )
+    else:
+      result.add c.genWasMoved(tmp)
+      var m = c.genCopy(tmp, n, {})
+      m.add p(n, c, s, normal)
+      c.finishCopy(m, n, {}, isFromSink = true)
+      result.add m
+    if isLValue(n) and not isCapturedVar(n) and nTyp.skipTypes(abstractInst).kind != tyRef and c.inSpawn == 0:
+      message(c.graph.config, n.info, hintPerformance,
+        ("passing '$1' to a sink parameter introduces an implicit copy; " &
+        "if possible, rearrange your program's control flow to prevent it") % $n)
+    if c.inEnsureMove > 0:
+      localError(c.graph.config, n.info, errFailedMove,
+        ("cannot move '$1', passing '$1' to a sink parameter introduces an implicit copy") % $n)
+  else:
     if c.graph.config.selectedGC in {gcArc, gcOrc, gcAtomicArc}:
       assert(not containsManagedMemory(nTyp))
     if nTyp.skipTypes(abstractInst).kind in {tyOpenArray, tyVarargs}:
       localError(c.graph.config, n.info, "cannot create an implicit openArray copy to be passed to a sink parameter")
-    return p(n, c, s, normal)
-  result = newNodeIT(nkStmtListExpr, n.info, n.typ)
-  let tmp = c.getTemp(s, nTyp, n.info, needsInit = false)
-  let typ = nTyp.skipTypes({tyGenericInst, tyAlias, tySink})
-  let op = getAttachedOp(c.graph, typ, attachedDup)
-  if op != nil and tfHasOwned notin typ.flags:
-    if sfError in op.flags:
-      c.checkForErrorPragma(nTyp, n, "=dup")
-    else:
-      let copyOp = getAttachedOp(c.graph, typ, attachedAsgn)
-      if copyOp != nil and sfError in copyOp.flags and
-         sfOverridden notin op.flags:
-        c.checkForErrorPragma(nTyp, n, "=dup", inferredFromCopy = true)
-
-    let src = p(n, c, s, normal)
-    var newCall = newTreeIT(nkCall, src.info, src.typ,
-          newSymNode(op),
-          src)
-    c.finishCopy(newCall, n, {}, isFromSink = true)
-    result.add newTreeI(nkFastAsgn,
-        src.info, tmp,
-        newCall
-    )
-  else:
-    result.add c.genWasMoved(tmp)
-    var m = c.genCopy(tmp, n, {})
-    m.add p(n, c, s, normal)
-    c.finishCopy(m, n, {}, isFromSink = true)
-    result.add m
-  if isLValue(n) and not isCapturedVar(n) and nTyp.skipTypes(abstractInst).kind != tyRef and c.inSpawn == 0:
-    message(c.graph.config, n.info, hintPerformance,
-      ("passing '$1' to a sink parameter introduces an implicit copy; " &
-      "if possible, rearrange your program's control flow to prevent it") % $n)
-  if c.inEnsureMove > 0:
-    localError(c.graph.config, n.info, errFailedMove,
-      ("cannot move '$1', passing '$1' to a sink parameter introduces an implicit copy") % $n)
+    result.add newTree(nkAsgn, tmp, p(n, c, s, normal))
   # Since we know somebody will take over the produced copy, there is
   # no need to destroy it.
   result.add tmp
@@ -540,7 +519,7 @@ proc ensureDestruction(arg, orig: PNode; c: var Con; s: var Scope): PNode =
     # produce temp creation for (fn, env). But we need to move 'env'?
     # This was already done in the sink parameter handling logic.
     result = newNodeIT(nkStmtListExpr, arg.info, arg.typ)
-    let tmp = c.getTemp(s, arg.typ, arg.info, true)
+    let tmp = c.getTemp(s, arg.typ, arg.info)
     result.add c.genSink(s, tmp, arg, {IsDecl})
     result.add tmp
     s.final.add c.genDestroy(tmp)
@@ -580,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))
@@ -619,7 +598,7 @@ template processScopeExpr(c: var Con; s: var Scope; ret: PNode, processCall: unt
   # There is a possibility to do this check: s.wasMoved.len > 0 or s.final.len > 0
   # later and use it to eliminate the temporary when theres no need for it, but its
   # tricky because you would have to intercept moveOrCopy at a certain point
-  let tmp = c.getTemp(s.parent[], ret.typ, ret.info, needsInit = true)
+  let tmp = c.getTemp(s.parent[], ret.typ, ret.info)
   tmp.sym.flags = tmpFlags
   let cpy = if hasDestructor(c, ret.typ) and
                 ret.typ.kind notin {tyOpenArray, tyVarargs}:
@@ -780,7 +759,7 @@ proc pRaiseStmt(n: PNode, c: var Con; s: var Scope): PNode =
       result = copyNode(n)
       result.add call
     else:
-      let tmp = c.getTemp(s, n[0].typ, n.info, needsInit = true)
+      let tmp = c.getTemp(s, n[0].typ, n.info)
       var m = c.genCopyNoCheck(tmp, n[0], attachedAsgn)
       m.add p(n[0], c, s, normal)
       c.finishCopy(m, n[0], {}, isFromSink = false)
@@ -810,23 +789,6 @@ proc hasCustomDestructor(c: Con, t: PType): bool =
     obj = skipTypes(obj.baseClass, abstractPtrs)
     result = result or isCustomDestructor(c, obj)
 
-const
-  exprBranchKinds = {nkStmtListExpr, nkBlockExpr, nkIfExpr, nkCaseStmt,
-                     nkTryStmt, nkPragmaBlock}
-
-proc distributeAsgn(asgnKind: TNodeKind; dest, ri: PNode; c: var Con; s: var Scope): PNode =
-  ## Distributes an assignment ``dest = ri`` into the leaf expressions of
-  ## ``ri`` when ``ri`` is an expression-based control flow construct. This
-  ## avoids creating pointless intermediate temporaries (bug #25850). The
-  ## descent is recursive so that nestings like ``block: ...; if c: a else: b``
-  ## assign directly to ``dest`` instead of going through a temp per branch.
-  if ri.kind in exprBranchKinds:
-    template process(child, s): untyped =
-      distributeAsgn(asgnKind, dest, child, c, s)
-    handleNestedTempl(ri, process, willProduceStmt = true)
-  else:
-    result = newTree(asgnKind, dest, p(ri, c, s, consumed))
-
 proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSingleUsedTemp}; inReturn = false): PNode =
   if n.kind in {nkStmtList, nkStmtListExpr, nkBlockStmt, nkBlockExpr, nkIfStmt,
                 nkIfExpr, nkCaseStmt, nkWhen, nkWhileStmt, nkParForStmt, nkTryStmt, nkPragmaBlock}:
@@ -973,9 +935,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):
@@ -991,15 +950,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
@@ -1028,11 +979,6 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
         result = moveOrCopy(p(n[0], c, s, mode), n[1], c, s, flags)
       elif isDiscriminantField(n[0]):
         result = c.genDiscriminantAsgn(s, n)
-      elif n[1].kind in exprBranchKinds:
-        # Distribute the assignment into each branch to avoid
-        # creating pointless temporaries for expression-based control flow.
-        let dest = p(n[0], c, s, mode)
-        result = distributeAsgn(n.kind, dest, n[1], c, s)
       else:
         result = copyNode(n)
         result.add p(n[0], c, s, mode)
@@ -1157,30 +1103,24 @@ proc sameLocation*(a, b: PNode): bool =
     else: false
 
 proc genFieldAccessSideEffects(c: var Con; s: var Scope; dest, ri: PNode; flags: set[MoveOrCopyFlag] = {}): PNode =
-  result = newNodeI(nkStmtList, ri.info)
-  let newAccess = stabilizeBracketIndex(ri, c, result)
-  let snk = c.genSink(s, dest, newAccess, flags)
-  result.add snk
-  result.add c.genWasMoved(newAccess)
+  # with side effects
+  var temp = newSym(skLet, getIdent(c.graph.cache, "bracketTmp"), c.idgen, c.owner, ri[1].info)
+  temp.typ = ri[1].typ
+  var v = newNodeI(nkLetSection, ri[1].info)
+  let tempAsNode = newSymNode(temp)
 
-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, needsInit = true)
-    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
+  var vpart = newNodeI(nkIdentDefs, tempAsNode.info, 3)
+  vpart[0] = tempAsNode
+  vpart[1] = newNodeI(nkEmpty, tempAsNode.info)
+  vpart[2] = ri[1]
+  v.add(vpart)
+
+  var newAccess = copyNode(ri)
+  newAccess.add ri[0]
+  newAccess.add tempAsNode
+
+  var snk = c.genSink(s, dest, newAccess, flags)
+  result = newTree(nkStmtList, v, snk, c.genWasMoved(newAccess))
 
 proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopyFlag] = {}): PNode =
   var ri = ri
@@ -1208,7 +1148,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):
@@ -1257,22 +1197,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/jsgen.nim

@@ -34,7 +34,7 @@ import
   ropes, wordrecg, renderer,
   cgmeth, lowerings, sighashes, modulegraphs, lineinfos,
   transf, injectdestructors, sourcemap, astmsgs, pushpoppragmas,
-  mangleutils, varpartitions
+  mangleutils
 
 import pipelineutils
 
@@ -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("^")
@@ -1294,16 +1291,14 @@ proc genAsgnAux(p: PProc, x, y: PNode, noCopyNeeded: bool) =
     xtyp = etySeq
   case xtyp
   of etySeq:
-    if x.typ.kind in {tyVar, tyLent} or (needsNoCopy(p, y) and needsNoCopy(p, x)) or noCopyNeeded or
-        (x.kind == nkSym and sfCursor in x.sym.flags):
+    if x.typ.kind in {tyVar, tyLent} or (needsNoCopy(p, y) and needsNoCopy(p, x)) or noCopyNeeded:
       lineF(p, "$1 = $2;$n", [a.rdLoc, b.rdLoc])
     else:
       useMagic(p, "nimCopy")
       lineF(p, "$1 = nimCopy(null, $2, $3);$n",
                [a.rdLoc, b.res, genTypeInfo(p, y.typ)])
   of etyObject:
-    if x.typ.kind in {tyVar, tyLent, tyOpenArray, tyVarargs} or (needsNoCopy(p, y) and needsNoCopy(p, x)) or noCopyNeeded or
-        (x.kind == nkSym and sfCursor in x.sym.flags):
+    if x.typ.kind in {tyVar, tyLent, tyOpenArray, tyVarargs} or (needsNoCopy(p, y) and needsNoCopy(p, x)) or noCopyNeeded:
       lineF(p, "$1 = $2;$n", [a.rdLoc, b.rdLoc])
     else:
       useMagic(p, "nimCopy")
@@ -1376,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")
@@ -1464,20 +1458,6 @@ proc genCheckedFieldOp(p: PProc, n: PNode, addrTyp: PType, r: var TCompRes) =
     r.res = "$1.$2" % [tmp, field.loc.snippet]
   r.kind = resExpr
 
-proc isVarOpenArrayParam(n: PNode): bool =
-  ## True if `n` resolves to a `var openArray` parameter. The JS backend
-  ## represents such parameters as a `{base, off, len}` slice view so that
-  ## writes through a `toOpenArray` view reach the caller's storage (bug #15952).
-  var it = n
-  while true:
-    case it.kind
-    of nkHiddenDeref, nkDerefExpr, nkHiddenAddr, nkAddr: it = it[0]
-    of nkHiddenStdConv, nkConv, nkObjDownConv, nkObjUpConv: it = it[1]
-    else: break
-  result = it.kind == nkSym and it.sym.kind == skParam and
-    it.sym.typ != nil and it.sym.typ.kind == tyVar and
-    it.sym.typ.len > 0 and it.sym.typ[0].kind == tyOpenArray
-
 proc genArrayAddr(p: PProc, n: PNode, r: var TCompRes) =
   var
     a, b: TCompRes = default(TCompRes)
@@ -1486,19 +1466,6 @@ proc genArrayAddr(p: PProc, n: PNode, r: var TCompRes) =
   let m = if n.kind == nkHiddenAddr: n[0] else: n
   gen(p, m[0], a)
   gen(p, m[1], b)
-  if isVarOpenArrayParam(m[0]):
-    # `var openArray` param is a `{base, off, len}` view; index the base with
-    # the offset applied. `m[0]` is a plain param name, safe to reference
-    # repeatedly (no side effects, so no temp needed).
-    let pn = a.rdLoc
-    r.address = "($1).base" % [pn]
-    if optBoundsCheck in p.options:
-      useMagic(p, "chckIndx")
-      r.res = "($1).off + chckIndx($2, 0, ($1).len - 1)" % [pn, b.rdLoc]
-    else:
-      r.res = "($1).off + ($2)" % [pn, b.rdLoc]
-    r.kind = resExpr
-    return
   #internalAssert p.config, a.typ != etyBaseIndex and b.typ != etyBaseIndex
   let (x, tmp) = maybeMakeTemp(p, m[0], a)
   r.address = x
@@ -1561,7 +1528,7 @@ proc genSymAddr(p: PProc, n: PNode, typ: PType, r: var TCompRes) =
     r.res = s.loc.snippet
     r.address = ""
     r.typ = etyNone
-  of skVar, skLet, skResult, skTemp, skForVar:
+  of skVar, skLet, skResult:
     r.kind = resExpr
     let jsType = mapType(p):
       if typ.isNil:
@@ -1619,11 +1586,7 @@ proc genAddr(p: PProc, n: PNode, r: var TCompRes) =
     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)
+      gen(p, n[0], r)
     of nkHiddenAddr:
       gen(p, n[0], r)
     of nkConv:
@@ -1767,47 +1730,8 @@ proc genArgNoParam(p: PProc, n: PNode, r: var TCompRes) =
   else:
     r.res.add(a.res)
 
-proc genVarOpenArrayArg(p: PProc, n: PNode, r: var TCompRes) =
-  ## Emit a `{base, off, len}` slice view for an argument to a `var openArray`
-  ## parameter (bug #15952). The view always aliases the base storage, so writes
-  ## through the callee's `openArray` reach the caller's array/seq/typed array.
-  var b, lo, hi, v: TCompRes = default(TCompRes)
-  # the argument reaches codegen as `addr(toOpenArray(x, lo, hi))` (possibly
-  # under conversions); unwrap to the actual `toOpenArray` call.
-  var sl = n
-  while true:
-    case sl.kind
-    of nkHiddenAddr, nkAddr, nkHiddenDeref, nkDerefExpr: sl = sl[0]
-    of nkHiddenStdConv, nkConv, nkObjDownConv, nkObjUpConv: sl = sl[1]
-    else: break
-  if sl.kind in nkCallKinds and getMagic(sl) == mSlice:
-    gen(p, sl[1], b)
-    gen(p, sl[2], lo)
-    gen(p, sl[3], hi)
-    if isVarOpenArrayParam(sl[1]):
-      # slicing a `var openArray` view: rebase onto the same underlying storage
-      r.res = "{base: ($1).base, off: ($1).off + $2, len: $3 - $2 + 1}" % [
-        b.rdLoc, lo.rdLoc, hi.rdLoc]
-    else:
-      r.res = "{base: $1, off: $2, len: $3 - $2 + 1}" % [
-        b.rdLoc, lo.rdLoc, hi.rdLoc]
-  elif isVarOpenArrayParam(sl):
-    # already a view from another `var openArray` param: forward it unchanged
-    gen(p, sl, b)
-    r.res = b.rdLoc
-  else:
-    # a whole array/seq/typed-array value: wrap with a zero offset
-    gen(p, n, v)
-    r.res = "{base: $1, off: 0, len: ($1).length}" % [v.rdLoc]
-  r.kind = resExpr
-
 proc genArg(p: PProc, n: PNode, param: PSym, r: var TCompRes; emitted: ptr int = nil) =
   var a: TCompRes = default(TCompRes)
-  if param.typ != nil and param.typ.kind == tyVar and param.typ[0].kind == tyOpenArray:
-    # `var openArray` params are passed as a `{base, off, len}` slice view.
-    genVarOpenArrayArg(p, n, a)
-    r.res.add(a.rdLoc)
-    return
   gen(p, n, a)
   if skipTypes(param.typ, abstractVar).kind in {tyOpenArray, tyVarargs} and
       a.typ == etyBaseIndex:
@@ -1817,13 +1741,6 @@ proc genArg(p: PProc, n: PNode, param: PSym, r: var TCompRes; emitted: ptr int =
     r.res.add(", ")
     r.res.add(a.res)
     if emitted != nil: inc emitted[]
-  elif skipTypes(param.typ, abstractVar).kind == tyOpenArray and
-      isVarOpenArrayParam(n):
-    # a `var openArray` view passed to a read-only `openArray` param: materialize
-    # a snapshot so the callee sees a plain array.
-    var w: TCompRes = default(TCompRes)
-    gen(p, n, w)
-    r.res.add("(($1).base).slice(($1).off, ($1).off + ($1).len)" % [w.rdLoc])
   elif n.typ.kind in {tyVar, tyPtr, tyRef, tyLent, tyOwned} and
       n.kind in nkCallKinds and mapType(param.typ) == etyBaseIndex:
     # this fixes bug #5608:
@@ -2079,12 +1996,8 @@ proc createVar(p: PProc, typ: PType, indirect: bool): Rope =
     if indirect: result = "[$1]" % [result]
   of tyTuple:
     result = rope("{")
-    var first = true
     for i in 0..<t.len:
-      # Do not produce code for void types
-      if isEmptyType(t[i]): continue
-      if not first: result.add(", ")
-      first = false
+      if i > 0: result.add(", ")
       result.addf("Field$1: $2", [i.rope,
             createVar(p, t[i], false)])
     result.add("}")
@@ -2153,8 +2066,7 @@ proc genVarInit(p: PProc, v: PSym, n: PNode) =
     gen(p, n, a)
     case mapType(p, v.typ)
     of etyObject, etySeq:
-      if v.typ.kind in {tyOpenArray, tyVarargs} or needsNoCopy(p, n) or
-          sfCursor in v.flags:
+      if v.typ.kind in {tyOpenArray, tyVarargs} or needsNoCopy(p, n):
         s = a.res
       else:
         useMagic(p, "nimCopy")
@@ -2417,8 +2329,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)
@@ -2465,21 +2377,13 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
       useMagic(p, "nimCopy")
       r.res = "nimCopy(null, $1, $2)" % [x.rdLoc, genTypeInfo(p, n.typ)]
   of mOpenArrayToSeq:
-    if isVarOpenArrayParam(n[1]):
-      var x: TCompRes = default(TCompRes)
-      gen(p, n[1], x)
-      r.res = "(($1).base).slice(($1).off, ($1).off + ($1).len)" % [x.rdLoc]
-      r.kind = resExpr
-    else:
-      genCall(p, n, r)
+    genCall(p, n, r)
   of mDestroy, mTrace: discard "ignore calls to the default destructor"
   of mOrd: genOrd(p, n, r)
   of mLengthStr, mLengthSeq, mLengthOpenArray, mLengthArray:
     var x: TCompRes = default(TCompRes)
     gen(p, n[1], x)
-    if isVarOpenArrayParam(n[1]):
-      r.res = "($1).len" % [x.rdLoc]
-    elif skipTypes(n[1].typ, abstractInst).kind == tyCstring:
+    if skipTypes(n[1].typ, abstractInst).kind == tyCstring:
       let (a, tmp) = maybeMakeTemp(p, n[1], x)
       r.res = "(($1) == null ? 0 : ($2).length)" % [a, tmp]
     else:
@@ -2488,9 +2392,7 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
   of mHigh:
     var x: TCompRes = default(TCompRes)
     gen(p, n[1], x)
-    if isVarOpenArrayParam(n[1]):
-      r.res = "($1).len - 1" % [x.rdLoc]
-    elif skipTypes(n[1].typ, abstractInst).kind == tyCstring:
+    if skipTypes(n[1].typ, abstractInst).kind == tyCstring:
       let (a, tmp) = maybeMakeTemp(p, n[1], x)
       r.res = "(($1) == null ? -1 : ($2).length - 1)" % [a, tmp]
     else:
@@ -2532,7 +2434,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)
@@ -2573,24 +2475,11 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
     genCall(p, n, r)
   of mSlice:
     # arr.slice([begin[, end]]): 'end' is exclusive
-    # Fixed homogeneous numeric arrays lower to JS typed arrays; `slice`
-    # copies, which silently breaks `var openArray` write-through (bug #15952).
-    # `subarray` returns a live shared-buffer view with the same
-    # exclusive-end signature, so use it there; keep `slice` for seqs/strings.
     var x, y, z: TCompRes = default(TCompRes)
     gen(p, n[1], x)
     gen(p, n[2], y)
     gen(p, n[3], z)
-    if isVarOpenArrayParam(n[1]):
-      # re-slicing a `var openArray` view: materialize from the view's base/offset
-      r.res = "(($1).base).slice(($1).off + $2, ($1).off + $3 + 1)" % [
-        x.rdLoc, y.rdLoc, z.rdLoc]
-    else:
-      let baseTy = skipTypes(n[1].typ, abstractVarRange + {tyLent})
-      if baseTy.kind == tyArray and arrayTypeForElemType(p.config, elemType(baseTy)).len > 0:
-        r.res = "($1.subarray($2, $3 + 1))" % [x.rdLoc, y.rdLoc, z.rdLoc]
-      else:
-        r.res = "($1.slice($2, $3 + 1))" % [x.rdLoc, y.rdLoc, z.rdLoc]
+    r.res = "($1.slice($2, $3 + 1))" % [x.rdLoc, y.rdLoc, z.rdLoc]
     r.kind = resExpr
   of mMove:
     genMove(p, n, r)
@@ -2881,11 +2770,6 @@ proc genProc(oldProc: PProc, prc: PSym): Rope =
   var transformedBody = transformBody(p.module.graph, p.module.idgen, prc, {})
   if sfInjectDestructors in prc.flags:
     transformedBody = injectDestructorCalls(p.module.graph, p.module.idgen, prc, transformedBody)
-  else:
-    # JS has a GC, so the destructor pass is off; but the cursor (alias) analysis
-    # is independent of ownership and always memory-safe on a traced target.
-    # Running it lets last-use `var b = a` aliases skip the deep `nimCopy`.
-    computeCursors(prc, transformedBody, p.module.graph)
 
   p.nested: genStmt(p, transformedBody)
 
@@ -2991,8 +2875,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:
@@ -408,12 +407,6 @@ Consider:
 proc isTypeOf(n: PNode): bool =
   n.kind == nkSym and n.sym.magic in {mTypeOf, mType}
 
-proc isEnvTypeForRoutine(envTyp: PType; routine: PSym): bool =
-  ## True if `envTyp` is (maybe wrapped) env object type owned by `routine`, as
-  ## created by `getEnvTypeForOwner` / `createEnvObj`.
-  let obj = envTyp.skipTypes({tyOwned, tyRef, tyPtr})
-  result = obj.kind == tyObject and obj.owner.id == routine.id
-
 proc addClosureParam(c: var DetectionPass; fn: PSym; info: TLineInfo) =
   var cp = getEnvParam(fn)
   let owner = if fn.kind == skIterator: fn else: fn.skipGenericOwner
@@ -424,13 +417,7 @@ proc addClosureParam(c: var DetectionPass; fn: PSym; info: TLineInfo) =
     cp.typ = t
     addHiddenParam(fn, cp)
   elif cp.typ != t and fn.kind != skIterator:
-    # Nested `liftLambdas` uses a fresh `DetectionPass`, so `getEnvTypeForOwner`
-    # can allocate another PType for the same logical env; the hidden param from
-    # the inner pass is authoritative (bug #21242).
-    if isEnvTypeForRoutine(cp.typ, owner) and isEnvTypeForRoutine(t, owner):
-      c.ownerToType[owner.id] = cp.typ
-    else:
-      localError(c.graph.config, fn.info, "internal error: inconsistent environment type")
+    localError(c.graph.config, fn.info, "internal error: inconsistent environment type")
   #echo "adding closure to ", fn.name.s
 
 proc iterEnvHasUpField(g: ModuleGraph, iter: PSym): bool =
@@ -987,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/layouter.nim

@@ -451,13 +451,7 @@ proc emitTok*(em: var Emitter; L: Lexer; tok: Token) =
   elif tok.indent >= 0:
     var newlineKind = ltCrucialNewline
     if em.keepIndents > 0:
-      # Apply the requested --indent width to "don't touch" regions (if/block
-      # expressions) too: keep the relative offset from the enclosing block
-      # baseline, but rebase it onto indWidth. Otherwise a non-default
-      # --indent would leave these lines at the original column and inject
-      # invalid indentation (see #20078).
-      em.indentLevel = em.indentStack.high * em.indWidth +
-                       (tok.indent - em.indentStack[^1])
+      em.indentLevel = tok.indent
     elif (em.lastTok in (splitters + oprSet) and
         tok.tokType notin (closedPars - {tkBracketDotRi})):
       if tok.tokType in openPars and tok.indent > em.indentStack[^1]:

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
 
@@ -1349,7 +1322,7 @@ proc rawGetTok*(L: var Lexer, tok: var Token) =
           lexMessage(L, errGenerated, "invalid token: no whitespace between number and identifier")
     of '-':
       if L.buf[L.bufpos+1] in {'0'..'9'} and
-          (L.bufpos == 0 or L.buf[L.bufpos-1] in UnaryMinusWhitelist):
+          (L.bufpos-1 == 0 or L.buf[L.bufpos-1] in UnaryMinusWhitelist):
         # x)-23 # binary minus
         # ,-23  # unary minus
         # \n-78 # unary minus? Yes.

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))
@@ -602,34 +582,11 @@ proc checkSelfAssignment(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   cond.typ() = getSysType(c.g, c.info, tyBool)
   body.add genIf(c, cond, newTreeI(nkReturnStmt, c.info, newNodeI(nkEmpty, c.info)))
 
-proc genBulkCopySeq(c: var TLiftCtx; t: PType; body, x, y: PNode) =
-  ## Generates a call to nimCopySeqPayload for bulk memcpy of seq data.
-  let elemType = t.elementType
-  let sym = magicsys.getCompilerProc(c.g, "nimCopySeqPayload")
-  if sym == nil:
-    localError(c.g.config, c.info, "system module needs: nimCopySeqPayload")
-    return
-  var sizeOf = genBuiltin(c, mSizeOf, "sizeof", newNodeIT(nkType, c.info, elemType))
-  sizeOf.typ = getSysType(c.g, c.info, tyInt)
-  var alignOf = genBuiltin(c, mAlignOf, "alignof", newNodeIT(nkType, c.info, elemType))
-  alignOf.typ = getSysType(c.g, c.info, tyInt)
-  let call = newNodeI(nkCall, c.info)
-  call.add newSymNode(sym)
-  call.add newTreeIT(nkAddr, c.info, makePtrType(c.fn, x.typ, c.idgen), x)
-  call.add newTreeIT(nkAddr, c.info, makePtrType(c.fn, y.typ, c.idgen), y)
-  call.add sizeOf
-  call.add alignOf
-  call.typ = sym.typ.returnType
-  body.add call
-
 proc fillSeqOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   case c.kind
   of attachedDup:
     body.add setLenSeqCall(c, t, x, y)
-    if supportsCopyMem(t.elementType):
-      genBulkCopySeq(c, t, body, x, y)
-    else:
-      forallElements(c, t, body, x, y)
+    forallElements(c, t, body, x, y)
   of attachedAsgn, attachedDeepCopy:
     # we generate:
     # if x.p == y.p:
@@ -638,13 +595,9 @@ proc fillSeqOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     # var i = 0
     # while i < y.len: dest[i] = y[i]; inc(i)
     # This is usually more efficient than a destroy/create pair.
-    # For trivially copyable types, use bulk copyMem instead of element loop.
     checkSelfAssignment(c, t, body, x, y)
     body.add setLenSeqCall(c, t, x, y)
-    if supportsCopyMem(t.elementType):
-      genBulkCopySeq(c, t, body, x, y)
-    else:
-      forallElements(c, t, body, x, y)
+    forallElements(c, t, body, x, y)
   of attachedSink:
     let moveCall = genBuiltin(c, mMove, "move", x)
     moveCall.add y
@@ -659,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)
@@ -697,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)
@@ -719,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
@@ -818,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)
@@ -885,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
@@ -913,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)
@@ -941,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:
@@ -981,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)
@@ -999,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
@@ -1049,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:
@@ -1072,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)
@@ -1116,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)
 
@@ -1155,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)
 
@@ -1166,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)
@@ -1208,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)
@@ -1237,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
@@ -1250,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)
 
@@ -1321,7 +1268,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;
@@ -1376,8 +1323,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,14 +93,10 @@ type
     warnBareExcept = "BareExcept",
     warnImplicitDefaultValue = "ImplicitDefaultValue",
     warnIgnoredSymbolInjection = "IgnoredSymbolInjection",
-    warnStdPrefix = "StdPrefix",
-    warnUnknownNotes = "UnknownNotes",
-    warnLongLiterals = "LongLiterals",
+    warnStdPrefix = "StdPrefix"
+    warnUnknownNotes = "UnknownNotes"
     warnUser = "User",
     warnGlobalVarConstructorTemporary = "GlobalVarConstructorTemporary",
-    warnImplicitRangeConversion = "ImplicitRangeConversion",
-    warnSystemRangeConversion = "SystemRangeConversion",
-    warnInvalidCmpOp = "InvalidCmpOp",
     # hints
     hintSuccess = "Success", hintSuccessX = "SuccessX",
     hintCC = "CC",
@@ -114,7 +110,6 @@ 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
 
@@ -206,12 +201,8 @@ const
     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",
-    warnSystemRangeConversion: "implicit range conversion $1",
-    warnInvalidCmpOp: "$1",
     hintSuccess: "operation successful: $#",
     # keep in sync with `testament.isSuccess`
     hintSuccessX: "$build\n$loc lines; ${sec}s; $mem; proj: $project; out: $output",
@@ -245,7 +236,6 @@ 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"
   ]
@@ -266,9 +256,9 @@ type
 
 proc computeNotesVerbosity(): array[0..3, TNoteKinds] =
   result = default(array[0..3, TNoteKinds])
-  result[3] = {low(TNoteKind)..high(TNoteKind)} - {warnObservableStores, warnResultUsed, warnAnyEnumConv, warnBareExcept, warnStdPrefix, warnSystemRangeConversion}
+  result[3] = {low(TNoteKind)..high(TNoteKind)} - {warnObservableStores, warnResultUsed, warnAnyEnumConv, warnBareExcept, warnStdPrefix}
   result[2] = result[3] - {hintStackTrace, hintExtendedContext, hintDeclaredLoc, hintProcessingStmt}
-  result[1] = result[2] - {warnImplicitRangeConversion, warnProveField, warnProveIndex,
+  result[1] = result[2] - {warnProveField, warnProveIndex,
     warnGcUnsafe, hintPath, hintDependency, hintCodeBegin, hintCodeEnd,
     hintSource, hintGlobalVar, hintGCStats, hintMsgOrigin, hintPerformance}
   result[0] = result[1] - {hintSuccessX, hintSuccess, hintConf,

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) =
@@ -388,7 +387,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.
@@ -463,15 +462,6 @@ proc openShadowScope*(c: PContext) =
                           symbols: initStrTable(),
                           depthLevel: c.scopeDepth)
 
-proc rememberShadowDefs*(c: PContext) =
-  ## bug #25693: a template/macro operand's local definitions are sem-checked in
-  ## a shadow scope that is then discarded. Record those definitions so that a
-  ## later re-emission (e.g. a captured `typed` fragment expanded more than once)
-  ## can be detected as a redefinition rather than silently miscompiled.
-  for s in c.currentScope.symbols:
-    if s.kind in {skVar, skLet, skForVar} and {sfGenSym, sfWasGenSym} * s.flags == {}:
-      c.shadowDiscardedDefs.incl s.id
-
 proc closeShadowScope*(c: PContext) =
   ## closes the shadow scope, but doesn't merge any of the symbols
   ## Does not check for unused symbols or missing forward decls since a macro

compiler/magicsys.nim

@@ -11,7 +11,7 @@
 
 import
   ast, astalgo, msgs, platform, idents,
-  modulegraphs, lineinfos, types
+  modulegraphs, lineinfos
 
 export createMagic
 
@@ -134,7 +134,7 @@ proc getNimScriptSymbol*(g: ModuleGraph; name: string): PSym =
 proc resetNimScriptSymbols*(g: ModuleGraph) = g.exposed = initStrTable()
 
 proc getMagicEqSymForType*(g: ModuleGraph; t: PType; info: TLineInfo): PSym =
-  case t.skipTypes(abstractRange).kind
+  case t.kind
   of tyInt,  tyInt8, tyInt16, tyInt32, tyInt64,
      tyUInt, tyUInt8, tyUInt16, tyUInt32, tyUInt64:
     result = getSysMagic(g, info, "==", mEqI)
@@ -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
@@ -410,15 +408,9 @@ iterator methodsForGeneric*(g: ModuleGraph; t: PType): (int, PSym) =
 proc addMethodToGeneric*(g: ModuleGraph; module: int; t: PType; col: int; m: PSym) =
   g.methodsPerGenericType.mgetOrPut(t.itemId, @[]).add (col, LazySym(sym: m))
 
-proc hasDisabledOp(g: ModuleGraph; t: PType; kind: TTypeAttachedOp): bool =
-  let op = getAttachedOp(g, t, kind)
-  result = op != nil and sfError in op.flags
-
 proc hasDisabledAsgn*(g: ModuleGraph; t: PType): bool =
-  result = hasDisabledOp(g, t, attachedAsgn)
-
-proc hasDisabledDup*(g: ModuleGraph; t: PType): bool =
-  result = hasDisabledOp(g, t, attachedDup)
+  let op = getAttachedOp(g, t, attachedAsgn)
+  result = op != nil and sfError in op.flags
 
 proc copyTypeProps*(g: ModuleGraph; module: int; dest, src: PType) =
   for k in low(TTypeAttachedOp)..high(TTypeAttachedOp):
@@ -462,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/nilcheck.nim

@@ -183,6 +183,12 @@ func `<`*(a: ExprIndex, b: ExprIndex): bool =
 func `<=`*(a: ExprIndex, b: ExprIndex): bool =
   a.int16 <= b.int16
 
+func `>`*(a: ExprIndex, b: ExprIndex): bool =
+  a.int16 > b.int16
+
+func `>=`*(a: ExprIndex, b: ExprIndex): bool =
+  a.int16 >= b.int16
+
 func `==`*(a: ExprIndex, b: ExprIndex): bool =
   a.int16 == b.int16
 

compiler/nim.cfg

@@ -11,9 +11,6 @@ define:nimPreviewRangeDefault
 define:nimPreviewNonVarDestructor
 define:nimPreviewCheckedClose
 define:nimPreviewAsmSemSymbol
-define:nimPreviewCStringComparisons
-define:nimPreviewDuplicateModuleError
-
 threads:off
 
 #import:"$projectpath/testability"
@@ -65,7 +62,3 @@ define:useStdoutAsStdmsg
 @if nimHasVtables:
   experimental:vtables
 @end
-
-@if nimHasImplicitRangeConversion:
-  warning[ImplicitRangeConversion]:off
-@end

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* = "2025"
 
   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]
 
@@ -225,7 +222,7 @@ type
     strictEffects,
     unicodeOperators, # deadcode
     flexibleOptionalParams,
-    strictDefs,
+    strictDefs, # deadcode
     strictCaseObjects,
     inferGenericTypes,
     openSym, # remove nfDisabledOpenSym when this is default
@@ -251,16 +248,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
-    procParamTypeBackendAliases
-      ## Keep the old proc type compatibility rules that ignore backend
-      ## c type aliases.
-    injectedSymbolRedefinition
-      ## Allow a template to inject a symbol *definition* that is then emitted
-      ## more than once (e.g. a `typed` argument captured by a `{.dirty.}`
-      ## template and re-emitted). This is a redefinition and rejected by
-      ## default; enabling this restores the old, unsound behavior. See #25693.
 
   SymbolFilesOption* = enum
     disabledSf, writeOnlySf, readOnlySf, v2Sf, stressTest
@@ -415,7 +402,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
@@ -517,7 +503,7 @@ const
     optHints, optStackTrace, optLineTrace, # consider adding `optStackTraceMsgs`
     optTrMacros, optStyleCheck, optCursorInference}
   DefaultGlobalOptions* = {optThreadAnalysis, optExcessiveStackTrace,
-    optJsBigInt64, optItaniumMangle}
+    optJsBigInt64}
 
 proc getSrcTimestamp(): DateTime =
   try:
@@ -592,7 +578,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
@@ -650,7 +635,6 @@ proc isDefined*(conf: ConfigRef; symbol: string): bool =
     of "x86": result = conf.target.targetCPU == cpuI386
     of "itanium": result = conf.target.targetCPU == cpuIa64
     of "x8664": result = conf.target.targetCPU == cpuAmd64
-    of "wasm": result = conf.target.targetCPU in {cpuWasm32, cpuWasm64}
     of "posix", "unix":
       result = conf.target.targetOS in {osLinux, osMorphos, osSkyos, osIrix, osPalmos,
                             osQnx, osAtari, osAix,
@@ -1050,9 +1034,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/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, cpuWasm64
+    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),
@@ -249,8 +248,7 @@ const
     (name: "esp", intSize: 32, endian: littleEndian, floatSize: 64, bit: 32),
     (name: "wasm32", intSize: 32, endian: littleEndian, floatSize: 64, bit: 32),
     (name: "e2k", intSize: 64, endian: littleEndian, floatSize: 64, bit: 64),
-    (name: "loongarch64", intSize: 64, endian: littleEndian, floatSize: 64, bit: 64),
-    (name: "wasm64", intSize: 64, endian: littleEndian, floatSize: 64, bit: 64)]
+    (name: "loongarch64", intSize: 64, endian: littleEndian, floatSize: 64, bit: 64)]
 
 type
   Target* = object

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)
@@ -893,7 +893,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 +947,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:
@@ -1409,12 +1405,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
@@ -229,7 +229,6 @@ proc put(g: var TSrcGen, kind: TokType, s: string; sym: PSym = nil) =
   inc(g.lineLen, s.len)
 
 proc putComment(g: var TSrcGen, s: string) =
-  const SpecialWhitespace = {' ', '\t', '\r', '\n', '\0'}
   if s.len == 0: return
   var i = 0
   let hi = s.len - 1
@@ -259,12 +258,12 @@ proc putComment(g: var TSrcGen, s: string) =
       # gets too long:
       # compute length of the following word:
       var j = i
-      while j <= hi and s[j] notin SpecialWhitespace: inc(j)
+      while j <= hi and s[j] > ' ': inc(j)
       if not isCode and (g.col + (j - i) > MaxLineLen):
         put(g, tkComment, com)
         optNL(g, ind)
         com = "## "
-      while i <= hi and s[i] notin SpecialWhitespace:
+      while i <= hi and s[i] > ' ':
         com.add(s[i])
         inc(i)
   put(g, tkComment, com)
@@ -328,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)
 
@@ -415,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 & "\"\"\""
@@ -570,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")
@@ -622,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:
@@ -1013,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:
@@ -1358,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}
@@ -1430,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)
@@ -1481,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, "(")
@@ -1766,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

@@ -89,18 +89,6 @@ proc fitNodePostMatch(c: PContext, formal: PType, arg: PNode): PNode =
     changeType(c, x, formal, check=true)
   result = arg
   result = skipHiddenSubConv(result, c.graph, c.idgen)
-  # Walk through nested statement-list/block expressions to find the innermost
-  # value node. Empty containers (e.g. `@[]`) inside `nkStmtListExpr` wrappers
-  # need their type resolved to match the formal type, otherwise the C codegen
-  # cannot map `tyEmpty` to a concrete type (fixes #25945).
-  var tail = result
-  while tail.kind in {nkStmtList, nkStmtListExpr, nkBlockStmt, nkBlockExpr, nkPragmaBlock} and tail.len > 0:
-    tail = tail.lastSon
-
-  if tail.typ != nil and tail.typ.isEmptyContainer and
-        formal.kind notin {tyUntyped, tyBuiltInTypeClass, tyAnything}:
-    changeType(c, tail, formal, check=true)
-
   # mark inserted converter as used:
   var a = result
   if a.kind == nkHiddenDeref: a = a[0]
@@ -117,12 +105,9 @@ proc fitNode(c: PContext, formal: PType, arg: PNode; info: TLineInfo): PNode =
     result.typ() = formal
   elif arg.kind in nkSymChoices and formal.skipTypes(abstractInst).kind == tyEnum:
     # Pick the right 'sym' from the sym choice by looking at 'formal' type:
-    # The choice candidates may be wrapped in `var`/`lent` when they come from
-    # a loop-local view, but for enum disambiguation only the underlying enum
-    # type matters.
     result = nil
     for ch in arg:
-      if sameType(ch.typ.skipTypes({tyVar, tyLent}), formal):
+      if sameType(ch.typ, formal):
         return ch
     typeMismatch(c.config, info, formal, arg.typ, arg)
   else:
@@ -262,26 +247,6 @@ proc newSymG*(kind: TSymKind, n: PNode, c: PContext): PSym =
     if result.kind notin {kind, skTemp}:
       localError(c.config, n.info, "cannot use symbol of kind '$1' as a '$2'" %
         [result.kind.toHumanStr, kind.toHumanStr])
-    # bug #25693: a local declared inside a template/macro operand (recorded in
-    # `shadowDiscardedDefs`) can be captured by a `{.dirty.}` template and
-    # re-emitted as a definition more than once. The first emission keeps the
-    # original symbol (so a leaked dirty-template name still resolves); every
-    # later emission gets a fresh copy, so distinct emissions don't share one
-    # symbol - which the destructor/liveness analysis would otherwise miscompile.
-    # Unlike a plain redefinition check this is control-flow agnostic, so the
-    # common "emit a `typed` body in several mutually-exclusive branches" pattern
-    # keeps working. gensym'ed locals (and ones derived from a gensym name) are
-    # excluded: the gensym machinery already keeps their names unique, and a
-    # fresh copy would reuse the unique name and clash in the same scope.
-    if kind in {skVar, skLet, skForVar} and
-        {sfGenSym, sfWasGenSym} * result.flags == {} and
-        result.id in c.shadowDiscardedDefs:
-      if containsOrIncl(c.realizedDefs, result.id):
-        let fresh = copySym(result, c.idgen)
-        fresh.ast = result.ast
-        put(c.p, result, fresh)
-        c.hasSymRedefs = true
-        result = fresh
     when false:
       if sfGenSym in result.flags and result.kind notin {skTemplate, skMacro, skParam}:
         # declarative context, so produce a fresh gensym:
@@ -356,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:
@@ -368,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:
@@ -381,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
@@ -418,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
@@ -430,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
@@ -460,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:
@@ -811,7 +755,6 @@ proc preparePContext*(graph: ModuleGraph; module: PSym; idgen: IdGenerator): PCo
   result.semTypeNode = semTypeNode
   result.instTypeBoundOp = sigmatch.instTypeBoundOp
   result.hasUnresolvedArgs = hasUnresolvedArgs
-  result.semAsgnOpr = semAsgnOpr
   result.templInstCounter = new int
 
   pushProcCon(result, module)

compiler/semcall.nim

@@ -131,7 +131,7 @@ proc pickBestCandidate(c: PContext, headSymbol: PNode,
   var sym = syms[0].s
   let name = sym.name
   var scope = syms[0].scope
-  c.openShadowScope
+
   if allowTypeBoundOps:
     for a in 1 ..< n.len:
       # for every already typed argument, add type bound ops
@@ -144,6 +144,7 @@ proc pickBestCandidate(c: PContext, headSymbol: PNode,
   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
@@ -160,13 +161,9 @@ proc pickBestCandidate(c: PContext, headSymbol: PNode,
           addTypeBoundSymbols(c.graph, arg.typ, name, filter, symMarker, syms)
 
       if z.state == csMatch:
-        # Iterator preference is heuristic in iterator-admitting contexts.
-        # The dedicated iterable path uses `iteratorPreference`, other
-        # context use exact-match bump
+        # little hack so that iterators are preferred over everything else:
         if sym.kind == skIterator:
-          if efPreferIteratorForIterable in flags:
-            inc(z.iteratorPreference)
-          elif not (efWantIterator notin flags and efWantIterable in flags):
+          if not (efWantIterator notin flags and efWantIterable in flags):
             inc(z.exactMatches, 200)
           else:
             dec(z.exactMatches, 200)
@@ -187,7 +184,7 @@ 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.
@@ -218,10 +215,6 @@ proc pickBestCandidate(c: PContext, headSymbol: PNode,
     scope = syms[nextSymIndex].scope
     inc(nextSymIndex)
 
-  if best.state == csMatch and best.calleeSym != nil and best.calleeSym.kind in {skTemplate, skMacro}:
-    c.closeShadowScope
-  else:
-    c.mergeShadowScope
 
 proc effectProblem(f, a: PType; result: var string; c: PContext) =
   if f.kind == tyProc and a.kind == tyProc:
@@ -252,6 +245,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
@@ -589,7 +590,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
@@ -679,7 +680,7 @@ proc bracketNotFoundError(c: PContext; n: PNode; flags: TExprFlags) =
   # copied from semOverloadedCallAnalyzeEffects, might be overkill:
   const baseFilter = {skProc, skFunc, skMethod, skConverter, skMacro, skTemplate}
   let filter =
-    if flags*{efInTypeof, efWantIterator, efWantIterable, efPreferIteratorForIterable} != {}:
+    if flags*{efInTypeof, efWantIterator, efWantIterable} != {}:
       baseFilter + {skIterator}
     else: baseFilter
   # this will add the errors:
@@ -694,14 +695,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
@@ -838,33 +832,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]))
@@ -900,10 +876,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]))
@@ -937,15 +911,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))
@@ -970,10 +944,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) =
@@ -989,7 +961,7 @@ proc setGenericParams(c: PContext, n, expectedParams: PNode) =
     if e.typ == nil:
       n[i].typ() = errorType(c)
     else:
-      n[i].typ() = e.typ
+      n[i].typ() = e.typ.skipTypes({tyTypeDesc})
 
 proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym, doError: bool): PNode =
   assert n.kind == nkBracketExpr

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]
 
@@ -56,18 +55,7 @@ type
     inst*: PInstantiation
 
   TExprFlag* = enum
-    efLValue,
-      # The expression is used as an assignable location.
-    efWantIterator,
-      # Admit iterator candidates and prefer them during overload resolution.
-    efWantIterable,
-      # Admit iterator candidates for expressions that may feed iterable-style
-      # chaining.
-    efPreferIteratorForIterable,
-      # Prefer iterator candidates for `iterable[T]` matching and wrap a
-      # successful iterator call as `tyIterable`.
-    efInTypeof,
-      # The expression is being semchecked under `typeof`.
+    efLValue, efWantIterator, efWantIterable, efInTypeof,
     efNeedStatic,
       # Use this in contexts where a static value is mandatory
     efPreferStatic,
@@ -164,6 +152,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.}
@@ -183,28 +172,7 @@ type
     inUncheckedAssignSection*: int
     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.
-    forwardFlagUpdates*: seq[(PType, PType)]
-      # (owner, son) pairs whose `propagateToOwner` ran on a not yet reified
-      # forward type and has to be redone in the final pass
-    staleTypeFlags*: IntSet
-      # ids of the owners in `forwardFlagUpdates`; their flags are provisional
-      # too, so reading them makes the reader provisional in turn
     inTypeofContext*: int
-
-    semAsgnOpr*: proc (c: PContext; n: PNode; k: TNodeKind): PNode {.nimcall.}
-    shadowDiscardedDefs*: IntSet
-      # ids of local symbols that were declared inside a template/macro operand's
-      # shadow scope and then discarded; re-emitting such a symbol as a
-      # definition gives a fresh copy so distinct emissions don't share a symbol.
-      # See bug #25693 and `rememberShadowDefs`.
-    realizedDefs*: IntSet
-      # ids from `shadowDiscardedDefs` already realized once; the first emission
-      # keeps the original symbol (so leaked dirty-template names still resolve),
-      # later emissions get a fresh copy.
-    hasSymRedefs*: bool
-      # set once a redefinition mapping has been installed; makes `getGenSym`
-      # consult the proc-con mapping for non-gensym symbols too.
-
   TBorrowState* = enum
     bsNone, bsReturnNotMatch, bsNoDistinct, bsGeneric, bsNotSupported, bsMatch
 
@@ -286,7 +254,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
@@ -296,10 +264,7 @@ proc get*(p: PProcCon; key: PSym): PSym =
   result = p.mapping.getOrDefault(key.itemId)
 
 proc getGenSym*(c: PContext; s: PSym): PSym =
-  # `c.hasSymRedefs` additionally routes ordinary (non-gensym) symbols through
-  # the mapping so a re-emitted definition can redirect them to its fresh copy,
-  # see bug #25693 and `newSymG`.
-  if sfGenSym notin s.flags and not c.hasSymRedefs: return s
+  if sfGenSym notin s.flags: return s
   var it = c.p
   while it != nil:
     result = get(it, s)
@@ -321,24 +286,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) =
@@ -349,26 +312,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(),
-    shadowDiscardedDefs: initIntSet(),
-    realizedDefs: initIntSet(),
-    staleTypeFlags: 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:
@@ -432,7 +391,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):
@@ -675,166 +635,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({tyAlias, tyVar, tySink})
-    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({tyAlias, tyVar, tySink})
-    let op = getAttachedOp(c.graph, t, attachedTrace)
-    if op != nil:
-      result[0] = newSymNode(op)
-  of attachedDup:
-    result = n
-    let t = n[1].typ.skipTypes({tyAlias, tyVar, tySink})
-    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({tyAlias, tyVar, tySink})
-    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({tyAlias, tyVar, tySink})
-    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'"
@@ -106,17 +107,13 @@ proc semExprWithType(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType
 
 proc semExprNoDeref(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
   result = semExprCheck(c, n, flags)
-  if result.typ == nil and efInTypeof in flags:
-    result.typ = c.voidType
-  elif result.typ == nil:
+  if result.typ == nil:
     localError(c.config, n.info, errExprXHasNoType %
                renderTree(result, {renderNoComments}))
     result.typ() = errorType(c)
 
 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
 
@@ -654,9 +651,6 @@ proc overloadedCallOpr(c: PContext, n: PNode): PNode =
     result = semExpr(c, result, flags = {efNoUndeclared})
 
 proc changeType(c: PContext; n: PNode, newType: PType, check: bool) =
-  template isViewTarget(t: PType): bool =
-    t.skipTypes({tyGenericInst, tyAlias, tySink}).kind in {tyVar, tyLent}
-
   case n.kind
   of nkCurly:
     for i in 0..<n.len:
@@ -685,15 +679,12 @@ proc changeType(c: PContext; n: PNode, newType: PType, check: bool) =
           if f == nil:
             globalError(c.config, m.info, "unknown identifier: " & m.sym.name.s)
             return
-          if not isViewTarget(f.typ):
-            changeType(c, n[i][1], f.typ, check)
+          changeType(c, n[i][1], f.typ, check)
         else:
-          if not isViewTarget(tup[i]):
-            changeType(c, n[i][1], tup[i], check)
+          changeType(c, n[i][1], tup[i], check)
     else:
       for i in 0..<n.len:
-        if not isViewTarget(tup[i]):
-          changeType(c, n[i], tup[i], check)
+        changeType(c, n[i], tup[i], check)
         when false:
           var m = n[i]
           var a = newNodeIT(nkExprColonExpr, m.info, newType[i])
@@ -734,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:
@@ -783,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
@@ -812,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:
@@ -840,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}:
@@ -885,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 =
@@ -956,41 +1035,33 @@ 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:
     #  echo "SUCCESS evaluated at compile time: ", call.renderTree
 
 proc semStaticExpr(c: PContext, n: PNode; expectedType: PType = nil): PNode =
-  let oldErrorCount = c.config.errorCounter
   inc c.inStaticContext
   openScope(c)
   let a = semExprWithType(c, n, expectedType = expectedType)
   closeScope(c)
   dec c.inStaticContext
-  if a.findUnresolvedStatic != nil or
-      c.config.errorCounter != oldErrorCount:
-    return a
+  if a.findUnresolvedStatic != nil: return a
   result = evalStaticExpr(c.module, c.idgen, c.graph, a, c.p.owner)
   if result.isNil:
     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 =
-  if flags*{efInTypeof, efWantIterator, efWantIterable, efPreferIteratorForIterable} != {}:
+  if flags*{efInTypeof, efWantIterator, efWantIterable} != {}:
     # consider: 'for x in pReturningArray()' --> we don't want the restriction
     # to 'skIterator' anymore; skIterator is preferred in sigmatch already
     # for typeof support.
@@ -1017,8 +1088,7 @@ proc semOverloadedCallAnalyseEffects(c: PContext, n: PNode, nOrig: PNode,
         # See bug #2051:
         result[0] = newSymNode(errorSym(c, n))
       elif callee.kind == skIterator:
-        if result.typ.kind != tyIterable and
-            flags * {efWantIterable, efPreferIteratorForIterable} != {}:
+        if efWantIterable in flags:
           let typ = newTypeS(tyIterable, c)
           rawAddSon(typ, result.typ)
           result.typ() = typ
@@ -1164,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)
 
@@ -1306,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:
@@ -1333,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
 
@@ -1409,11 +1475,7 @@ proc semSym(c: PContext, n: PNode, sym: PSym, flags: TExprFlags): PNode =
     # not sure the symbol really ends up being used:
     # var len = 0 # but won't be called
     # genericThatUsesLen(x) # marked as taking a closure?
-    # Lowered returns use resolved symbol nodes internally; warn only for
-    # source-level references to the implicit result variable.
-    if s.kind == skResult and
-        (n.kind != nkSym or nfFromTemplate in n.flags) and
-        hasWarn(c.config, warnResultUsed):
+    if hasWarn(c.config, warnResultUsed):
       message(c.config, n.info, warnResultUsed)
 
   of skGenericParam:
@@ -1541,7 +1603,7 @@ proc builtinFieldAccess(c: PContext; n: PNode; flags: var TExprFlags): PNode =
     return
 
   # extra flags since LHS may become a call operand:
-  n[0] = semExprWithType(c, n[0], flags + {efDetermineType, efWantIterable, efAllowSymChoice})
+  n[0] = semExprWithType(c, n[0], flags+{efDetermineType, efWantIterable, efAllowSymChoice})
   #restoreOldStyleType(n[0])
   var i = considerQuotedIdent(c, n[1], n)
   var ty = n[0].typ
@@ -1674,9 +1736,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:
@@ -1814,7 +1873,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, {})
@@ -1873,7 +1932,7 @@ proc borrowCheck(c: PContext, n, le, ri: PNode) =
     PathKinds0 = {nkDotExpr, nkCheckedFieldExpr,
                   nkBracketExpr, nkAddr, nkHiddenAddr,
                   nkObjDownConv, nkObjUpConv}
-    PathKinds1 = {nkHiddenStdConv, nkHiddenSubConv, nkCast}
+    PathKinds1 = {nkHiddenStdConv, nkHiddenSubConv}
 
   proc getRoot(n: PNode; followDeref: bool): PNode =
     result = n
@@ -1948,20 +2007,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))
 
@@ -1988,34 +2035,21 @@ proc semAsgn(c: PContext, n: PNode; mode=asgnNormal): PNode =
   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
@@ -2093,8 +2127,6 @@ proc semReturn(c: PContext, n: PNode): PNode =
       # optimize away ``result = result``:
       if result[0][1].kind == nkSym and result[0][1].sym == c.p.resultSym:
         result[0] = c.graph.emptyNode
-    elif c.p.resultSym != nil and hasWarn(c.config, warnResultUsed):
-      message(c.config, n.info, warnResultUsed)
   else:
     localError(c.config, n.info, "'return' not allowed here")
 
@@ -2235,8 +2267,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
@@ -2670,22 +2704,6 @@ proc semMagic(c: PContext, n: PNode, s: PSym, flags: TExprFlags; expectedType: P
   else:
     result = semDirectOp(c, n, flags, expectedType)
 
-proc semNimvmBranch(c: PContext, n: PNode, flags: TExprFlags): PNode =
-  let
-    oldOptionStack = c.optionStack[0..^1]
-    oldOptions = c.config.options
-    oldNotes = c.config.notes
-    oldWarningAsErrors = c.config.warningAsErrors
-    oldFeatures = c.features
-  try:
-    result = semExpr(c, n, flags)
-  finally:
-    c.optionStack = oldOptionStack
-    c.config.options = oldOptions
-    c.config.notes = oldNotes
-    c.config.warningAsErrors = oldWarningAsErrors
-    c.features = oldFeatures
-
 proc semWhen(c: PContext, n: PNode, semCheck = true): PNode =
   # If semCheck is set to false, ``when`` will return the verbatim AST of
   # the correct branch. Otherwise the AST will be passed through semStmt.
@@ -2722,7 +2740,7 @@ proc semWhen(c: PContext, n: PNode, semCheck = true): PNode =
       checkSonsLen(it, 2, c.config)
       if whenNimvm:
         if semCheck:
-          it[1] = semNimvmBranch(c, it[1], flags)
+          it[1] = semExpr(c, it[1], flags)
           typ = commonType(c, typ, it[1].typ)
         result = n # when nimvm is not elimited until codegen
       elif c.inGenericContext > 0:
@@ -2753,8 +2771,7 @@ proc semWhen(c: PContext, n: PNode, semCheck = true): PNode =
         discard
       elif result == nil or whenNimvm:
         if semCheck:
-          it[0] = if whenNimvm: semNimvmBranch(c, it[0], flags)
-                  else: semExpr(c, it[0], flags)
+          it[0] = semExpr(c, it[0], flags)
           typ = commonType(c, typ, it[0].typ)
           if typ != nil and typ.kind != tyUntyped:
             it[0] = fitNode(c, typ, it[0], it[0].info)
@@ -2791,21 +2808,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:
@@ -2813,11 +2825,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)
@@ -2832,14 +2842,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
@@ -2912,7 +2914,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)
@@ -2922,9 +2923,7 @@ 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})]`,
@@ -2945,21 +2944,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:
@@ -2970,37 +2955,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
 
@@ -3088,39 +3053,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) =
@@ -3366,7 +3320,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)
@@ -3616,7 +3569,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

@@ -36,8 +36,7 @@ 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:
         let fieldName = if c.tupleType.isNil: c.field.name.s
                         elif c.tupleType.n.isNil: "Field" & $c.tupleIndex
@@ -46,8 +45,7 @@ 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:
         var call = forLoop[^2]
         var tupl = call[i+1-ord(c.replaceByFieldName)]
         if c.field.isNil:

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 =

compiler/semgnrc.nim

@@ -129,19 +129,7 @@ proc semGenericStmtSymbol(c: PContext, n: PNode, s: PSym,
           result.typ() = nil
     onUse(n.info, s)
   of skParam:
-    if s.typ != nil and s.typ.kind == tyStatic and s.typ.n != nil:
-      # The enclosing routine gives this static parameter a concrete value.
-      # Keep that value so the nested generic can fold it as a compile-time
-      # expression instead of generating a runtime parameter reference.
-      result = s.typ.n
-    elif s.owner == c.p.owner:
-      # Parameters of the routine currently being semchecked stay as local
-      # identifiers
-      result = n
-    else:
-      # Preserve captured outer parameters so nested generic procs can still
-      # see them after the generic pre-pass.
-      result = newSymNode(s, n.info)
+    result = n
     onUse(n.info, s)
   of skType:
     if (s.typ != nil) and
@@ -286,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)
@@ -686,3 +673,4 @@ proc semConceptBody(c: PContext, n: PNode): PNode =
   )
   result = semGenericStmt(c, n, {withinConcept}, ctx)
   semIdeForTemplateOrGeneric(c, result, ctx.cursorInBody)
+

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

@@ -86,7 +86,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
@@ -102,7 +102,7 @@ proc annotateType*(n: PNode, t: PType; conf: ConfigRef; producedClosure: var boo
         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)
+        annotateType(n[i][1], field.sym.typ, conf)
         if field.delete:
           # only codegen fields from active case branches
           incl(n[i].flags, nfPreventCg)
@@ -111,11 +111,9 @@ proc annotateType*(n: PNode, t: PType; conf: ConfigRef; producedClosure: var boo
       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 +125,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 +140,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

@@ -35,28 +35,27 @@ proc semAddr(c: PContext; n: PNode): PNode =
   let x = semExprWithType(c, n)
   if x.kind == nkSym:
     x.sym.flags.incl(sfAddrTaken)
-  let aa = isAssignable(c, x)
-  if aa notin {arLValue, arLocalLValue, arAddressableConst, arLentValue} and
-     (aa != arDiscriminant or c.inUncheckedAssignSection <= 0):
+  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 =
-  let typExpr = semTypeOfImpl(c, n)
+  var m = BiggestInt 1 # typeOfIter
+  if n.len == 3:
+    let mode = semConstExpr(c, n[2])
+    if mode.kind != nkIntLit:
+      localError(c.config, n.info, "typeof: cannot evaluate 'mode' parameter at compile-time")
+    else:
+      m = mode.intVal
   result = newNodeI(nkTypeOfExpr, n.info)
+  inc c.inTypeofContext
+  defer: dec c.inTypeofContext # compiles can raise an exception
+  let typExpr = semExprWithType(c, n[1], if m == 1: {efInTypeof} else: {})
   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
@@ -225,7 +224,10 @@ proc evalTypeTrait(c: PContext; traitCall: PNode, operand: PType, context: PSym)
   of "stripGenericParams":
     result = uninstantiate(operand).toNode(traitCall.info)
   of "supportsCopyMem":
-    result = newIntNodeT(toInt128(ord(supportsCopyMem(operand))), traitCall, c.idgen, c.graph)
+    let t = operand.skipTypes({tyVar, tyLent, tyGenericInst, tyAlias, tySink, tyInferred})
+    let complexObj = containsGarbageCollectedRef(t) or
+                     hasDestructor(t)
+    result = newIntNodeT(toInt128(ord(not complexObj)), traitCall, c.idgen, c.graph)
   of "hasDefaultValue":
     result = newIntNodeT(toInt128(ord(not operand.requiresInit)), traitCall, c.idgen, c.graph)
   of "isNamedTuple":
@@ -233,17 +235,14 @@ 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":
-    var arg = operand.skipTypes(skippedTypes)
+    var arg = operand.skipTypes({tyGenericInst})
     let rec = semConstExpr(c, traitCall[2]).intVal != 0
-    while true:
-      let distinctArg = arg.skipTypes(skippedTypes + {tyGenericInst})
-      if distinctArg.kind != tyDistinct:
-        break
-      arg = distinctArg.base.skipTypes(skippedTypes)
+    while arg.kind == tyDistinct:
+      arg = arg.base.skipTypes(skippedTypes + {tyGenericInst})
       if not rec: break
     result = getTypeDescNode(c, arg, operand.owner, traitCall.info)
   of "rangeBase":
@@ -605,10 +604,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)
@@ -647,20 +645,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,
@@ -691,10 +718,5 @@ proc magicsAfterOverloadResolution(c: PContext, n: PNode,
     if n[1].kind in {nkStmtListExpr, nkBlockExpr,
               nkIfExpr, nkCaseStmt, nkTryStmt}:
       localError(c.config, n.info, "Nested expressions cannot be moved: '" & $n[1] & "'")
-  of mMove:
-    result = n
-    if isCursor(n[1]):
-      localError(c.config, n.info, errFailedMove,
-        "cannot move cursor '" & $n[1] & "'; a cursor does not own its value")
   else:
     result = n

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

compiler/sempass2.nim

@@ -82,12 +82,8 @@ type
     guards: TModel # nested guards
     locked: seq[PNode] # locked locations
     gcUnsafe, isRecursive, isTopLevel, hasSideEffect, inEnforcedGcSafe: bool
-    canRaiseDefect: bool # defects are deliberately omitted from `exc`
     isInnerProc: bool
     inEnforcedNoSideEffects: bool
-    isArrayIndexing: bool
-    currentExceptType: PType
-    unknownRaises: seq[(PSym, TLineInfo)]
     currOptions: TOptions
     optionsStack: seq[(TOptions, TNoteKinds)]
     config: ConfigRef
@@ -141,11 +137,6 @@ proc createTypeBoundOps(tracked: PEffects, typ: PType; info: TLineInfo; explicit
       createTypeBoundOps(tracked.graph, tracked.c, realType.lastSon, info)
 
   createTypeBoundOps(tracked.graph, tracked.c, typ, info, tracked.c.idgen)
-  for kind in TTypeAttachedOp:
-    let op = getAttachedOp(tracked.graph, typ, kind)
-    if op != nil and sfNeverRaises notin op.flags:
-      tracked.canRaiseDefect = true
-      break
   if (tfHasAsgn in typ.flags) or
       optSeqDestructors in tracked.config.globalOptions:
     tracked.owner.flags.incl sfInjectDestructors
@@ -154,66 +145,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; info: TLineInfo; 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
-    if a.kind == tyInt and f.sym != nil and f.sym.owner != nil and
-        sfSystemModule in f.sym.owner.flags and
-        (f.sym.name.s == "Positive" or
-          f.sym.name.s == "Natural"):
-      # Positive and Natural are special cases that we do not warn on with
-      # ImplicitRangeConversion, but may warn on with systemRangeConversion
-      # if that warning is enabled.
-      if conf.hasWarn(warnSystemRangeConversion):
-        message(conf, info, warnSystemRangeConversion,
-              typeToString(argType) & " -> " & typeToString(formalType))
-      result = false
-    else:
-      result = not isRangeSupertype(conf, f, a)
-  else:
-    result = false
-
-proc conversionCanRaiseDefect(conf: ConfigRef; destType, sourceType: PType): bool =
-  ## Keep this in sync with the range checks introduced by `transformConv`.
-  let
-    dest = destType.skipTypes(abstractVarRange)
-    source = sourceType.skipTypes(abstractVarRange)
-  case dest.kind
-  of tyInt..tyInt64, tyEnum, tyChar, tyUInt8..tyUInt32:
-    if not source.isOrdinalType:
-      result = dest.kind in tyInt..tyInt64
-    else:
-      result = firstOrd(conf, destType) > firstOrd(conf, sourceType) or
-        lastOrd(conf, sourceType) > lastOrd(conf, destType)
-  of tyFloat..tyFloat128:
-    result = destType.skipTypes(abstractVar).kind == tyRange
-  else:
-    result = false
-
 proc lockLocations(a: PEffects; pragma: PNode) =
   if pragma.kind != nkExprColonExpr:
     localError(a.config, pragma.info, "locks pragma without argument")
@@ -446,9 +377,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:
@@ -516,38 +445,9 @@ proc addRaiseEffect(a: PEffects, e, comesFrom: PNode) =
     if sameType(a.graph.excType(aa[i]), a.graph.excType(e)): return
 
   if e.typ != nil:
-    if isDefectException(e.typ):
-      a.canRaiseDefect = true
-    else:
+    if not isDefectException(e.typ):
       throws(a.exc, e, comesFrom)
 
-proc skipHiddenConv(n: PNode): PNode =
-  result = n
-  while true:
-    case result.kind
-    of nkHiddenStdConv, nkHiddenSubConv:
-      result = result[1]
-    else: break
-
-proc addRaiseEffectsFromExpr(a: PEffects, e, comesFrom: PNode) =
-  if e.isNil:
-    return
-  case e.kind
-  of nkStmtList, nkStmtListExpr, nkBlockStmt, nkBlockExpr:
-    if e.len > 0:
-      addRaiseEffectsFromExpr(a, e.lastSon.skipHiddenConv, comesFrom)
-  of nkIfExpr, nkIfStmt:
-    for branch in items(e):
-      if branch.len > 0:
-        addRaiseEffectsFromExpr(a, branch.lastSon.skipHiddenConv, comesFrom)
-  of nkCaseStmt:
-    for i in 1..<e.len:
-      let branch = e[i]
-      if branch.len > 0:
-        addRaiseEffectsFromExpr(a, branch.lastSon.skipHiddenConv, comesFrom)
-  else:
-    addRaiseEffect(a, e, comesFrom)
-
 proc addTag(a: PEffects, e, comesFrom: PNode) =
   var aa = a.tags
   for i in 0..<aa.len:
@@ -673,25 +573,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:
@@ -752,8 +638,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)
@@ -817,7 +701,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) =
@@ -826,7 +710,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
@@ -998,9 +882,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):
@@ -1012,14 +895,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)
 
@@ -1092,7 +967,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:
@@ -1102,25 +977,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):
@@ -1134,32 +990,6 @@ proc trackCall(tracked: PEffects; n: PNode) =
         markSideEffect(tracked, a, n.info)
   # p's effects are ours too:
   var a = n[0]
-  if a.kind == nkSym:
-    let s = a.sym
-    case s.magic
-    of mNone:
-      if {sfNeverRaises, sfImportc, sfCompilerProc} * s.flags == {} and
-          (sfSystemModule notin getModule(s).flags or
-           sfSystemRaisesDefect in s.flags):
-        tracked.canRaiseDefect = true
-    of mUnaryMinusI..mAbsI, mAddI..mPred:
-      if optOverflowCheck in tracked.currOptions:
-        tracked.canRaiseDefect = true
-    of mInc, mDec:
-      let typ = n[1].typ.skipTypes({tyGenericInst, tyAlias, tySink,
-                                    tyVar, tyLent, tyRange, tyDistinct})
-      if optOverflowCheck in tracked.currOptions and
-          typ.kind notin {tyUInt..tyUInt64}:
-        tracked.canRaiseDefect = true
-    of mDivU, mModU:
-      tracked.canRaiseDefect = true
-    of mAddF64..mDivF64:
-      if {optNaNCheck, optInfCheck} * tracked.currOptions != {}:
-        tracked.canRaiseDefect = true
-    else:
-      discard
-  else:
-    tracked.canRaiseDefect = true
   #if canRaise(a):
   #  echo "this can raise ", tracked.config $ n.info
   let op = a.typ
@@ -1204,9 +1034,7 @@ proc trackCall(tracked: PEffects; n: PNode) =
         else:
           if laxEffects notin tracked.c.config.legacyFeatures and a.kind == nkSym and
               a.sym.kind in routineKinds:
-            let (isHook, opKind) = findHookKind(a.sym.name.s)
-            if (not isHook) or opKind notin {attachedAsgn, attachedSink, attachedDup}:
-              propagateEffects(tracked, n, a.sym)
+            propagateEffects(tracked, n, a.sym)
       else:
         mergeRaises(tracked, effectList[exceptionEffects], n)
         mergeTags(tracked, effectList[tagEffects], n)
@@ -1237,17 +1065,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, tySink})
-      if a.sym != getAttachedOp(tracked.graph, t, opKind):
+      let t = n[1].typ.skipTypes({tyAlias, tyVar})
+      if a.sym != getAttachedOp(tracked.graph, t, TTypeAttachedOp(opKind)):
         createTypeBoundOps(tracked, t, n.info, explicit = true)
-        # replace builtin hooks with lifted ones
-        n = replaceHookMagic(tracked.c, n, opKind)
+        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):
@@ -1281,18 +1110,14 @@ type
   PragmaBlockContext = object
     oldLocked: int
     enforcedGcSafety, enforceNoSideEffects: bool
-    oldInEnforcedGcSafe, oldInEnforcedNoSideEffects: bool
     oldExc, oldTags, oldForbids: int
     exc, tags, forbids: PNode
-    excSource, tagsSource, forbidsSource: PNode
 
 proc createBlockContext(tracked: PEffects): PragmaBlockContext =
   var oldForbidsLen = 0
   if tracked.forbids != nil: oldForbidsLen = tracked.forbids.len
   result = PragmaBlockContext(oldLocked: tracked.locked.len,
     enforcedGcSafety: false, enforceNoSideEffects: false,
-    oldInEnforcedGcSafe: tracked.inEnforcedGcSafe,
-    oldInEnforcedNoSideEffects: tracked.inEnforcedNoSideEffects,
     oldExc: tracked.exc.len, oldTags: tracked.tags.len,
     oldForbids: oldForbidsLen)
 
@@ -1301,27 +1126,25 @@ proc applyBlockContext(tracked: PEffects, bc: PragmaBlockContext) =
   if bc.enforceNoSideEffects: tracked.inEnforcedNoSideEffects = true
 
 proc unapplyBlockContext(tracked: PEffects; bc: PragmaBlockContext) =
-  if bc.enforcedGcSafety: tracked.inEnforcedGcSafe = bc.oldInEnforcedGcSafe
-  if bc.enforceNoSideEffects:
-    tracked.inEnforcedNoSideEffects = bc.oldInEnforcedNoSideEffects
+  if bc.enforcedGcSafety: tracked.inEnforcedGcSafe = false
+  if bc.enforceNoSideEffects: tracked.inEnforcedNoSideEffects = false
   setLen(tracked.locked, bc.oldLocked)
   if bc.exc != nil:
     # beware that 'raises: []' is very different from not saying
     # anything about 'raises' in the 'cast' at all. Same applies for 'tags'.
     setLen(tracked.exc.sons, bc.oldExc)
     for e in bc.exc:
-      addRaiseEffect(tracked, e, if bc.excSource != nil: bc.excSource else: e)
+      addRaiseEffect(tracked, e, e)
   if bc.tags != nil:
     setLen(tracked.tags.sons, bc.oldTags)
     for t in bc.tags:
-      addTag(tracked, t, if bc.tagsSource != nil: bc.tagsSource else: t)
+      addTag(tracked, t, t)
   if bc.forbids != nil:
     setLen(tracked.forbids.sons, bc.oldForbids)
     for t in bc.forbids:
-      addNotTag(tracked, t, if bc.forbidsSource != nil: bc.forbidsSource else: t)
+      addNotTag(tracked, t, t)
 
-proc castBlock(tracked: PEffects, castPragma: PNode, bc: var PragmaBlockContext) =
-  let pragma = castPragma[1]
+proc castBlock(tracked: PEffects, pragma: PNode, bc: var PragmaBlockContext) =
   case whichPragma(pragma)
   of wGcSafe:
     bc.enforcedGcSafety = true
@@ -1334,7 +1157,6 @@ proc castBlock(tracked: PEffects, castPragma: PNode, bc: var PragmaBlockContext)
     else:
       bc.tags = newNodeI(nkArgList, pragma.info)
       bc.tags.add n
-    bc.tagsSource = castPragma
   of wForbids:
     let n = pragma[1]
     if n.kind in {nkCurly, nkBracket}:
@@ -1342,7 +1164,6 @@ proc castBlock(tracked: PEffects, castPragma: PNode, bc: var PragmaBlockContext)
     else:
       bc.forbids = newNodeI(nkArgList, pragma.info)
       bc.forbids.add n
-    bc.forbidsSource = castPragma
   of wRaises:
     let n = pragma[1]
     if n.kind in {nkCurly, nkBracket}:
@@ -1350,7 +1171,6 @@ proc castBlock(tracked: PEffects, castPragma: PNode, bc: var PragmaBlockContext)
     else:
       bc.exc = newNodeI(nkArgList, pragma.info)
       bc.exc.add n
-    bc.excSource = castPragma
   of wUncheckedAssign:
     discard "handled in sempass1"
   else:
@@ -1387,8 +1207,6 @@ proc allowCStringConv(n: PNode): bool =
 
 proc track(tracked: PEffects, n: PNode) =
   case n.kind
-  of nkTypeOfExpr:
-    discard "typeof() never evaluates its operand; not a definite-assignment use"
   of nkSym:
     useVar(tracked, n)
     if n.sym.typ != nil and tfHasAsgn in n.sym.typ.flags:
@@ -1402,11 +1220,10 @@ proc track(tracked: PEffects, n: PNode) =
     else:
       track(tracked, n[0])
   of nkRaiseStmt:
-    tracked.canRaiseDefect = true
     if n[0].kind != nkEmpty:
       n[0].info = n.info
       #throws(tracked.exc, n[0])
-      addRaiseEffectsFromExpr(tracked, n[0], n)
+      addRaiseEffect(tracked, n[0], n)
       for i in 0..<n.safeLen:
         track(tracked, n[i])
       createTypeBoundOps(tracked, n[0].typ, n.info)
@@ -1414,14 +1231,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:
@@ -1431,8 +1241,6 @@ proc track(tracked: PEffects, n: PNode) =
     for i in 0..<n.len: track(tracked, n[i])
     tracked.leftPartOfAsgn = oldLeftPartOfAsgn
   of nkCheckedFieldExpr:
-    if optFieldCheck in tracked.currOptions:
-      tracked.canRaiseDefect = true
     track(tracked, n[0])
     if tracked.config.hasWarn(warnProveField) or strictCaseObjects in tracked.c.features:
       checkFieldAccess(tracked.guards, n, tracked.config, strictCaseObjects in tracked.c.features)
@@ -1501,12 +1309,12 @@ proc track(tracked: PEffects, n: PNode) =
     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 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
@@ -1609,7 +1417,7 @@ proc track(tracked: PEffects, n: PNode) =
       of wNoSideEffect:
         bc.enforceNoSideEffects = true
       of wCast:
-        castBlock(tracked, pragmaList[i], bc)
+        castBlock(tracked, pragmaList[i][1], bc)
       else:
         discard
     applyBlockContext(tracked, bc)
@@ -1630,9 +1438,6 @@ proc track(tracked: PEffects, n: PNode) =
       if tracked.owner.kind != skMacro:
         createTypeBoundOps(tracked, n.typ, n.info)
   of nkHiddenStdConv, nkHiddenSubConv, nkConv:
-    if optRangeCheck in tracked.currOptions and
-        conversionCanRaiseDefect(tracked.config, n.typ, n[1].typ):
-      tracked.canRaiseDefect = true
     if n.kind in {nkHiddenStdConv, nkHiddenSubConv} and
         n.typ.skipTypes(abstractInst).kind == tyCstring and
         not allowCStringConv(n[1]):
@@ -1644,13 +1449,6 @@ proc track(tracked: PEffects, n: PNode) =
       message(tracked.config, n.info, warnPtrToCstringConv,
           $n[1].typ)
 
-    # Check for implicit range conversions. Compile-time constants are already
-    # fully known here, so only non-constant values need the downsizing warning.
-    if n.kind == nkHiddenStdConv and (not tracked.isArrayIndexing) and
-          shouldWarnRangeConversion(tracked.config, n.info, n.typ, n[1].typ) and
-          getConstExpr(tracked.ownerModule, n[1], tracked.c.idgen, tracked.graph) == nil:
-      message(tracked.config, n.info, warnImplicitRangeConversion,
-              typeToString(n[1].typ) & " -> " & typeToString(n.typ))
 
     let t = n.typ.skipTypes(abstractInst)
     if t.kind == tyEnum:
@@ -1670,11 +1468,6 @@ proc track(tracked: PEffects, n: PNode) =
       if optStaticBoundsCheck in tracked.currOptions:
         checkRange(tracked, n[1], n.typ)
   of nkObjUpConv, nkObjDownConv, nkChckRange, nkChckRangeF, nkChckRange64:
-    if n.kind in {nkObjUpConv, nkObjDownConv}:
-      if optObjCheck in tracked.currOptions:
-        tracked.canRaiseDefect = true
-    elif optRangeCheck in tracked.currOptions:
-      tracked.canRaiseDefect = true
     if n.len == 1:
       track(tracked, n[0])
       if tracked.owner.kind != skMacro:
@@ -1689,19 +1482,12 @@ proc track(tracked: PEffects, n: PNode) =
     if tracked.owner.kind != skMacro:
       createTypeBoundOps(tracked, n.typ, n.info)
   of nkBracketExpr:
-    if optBoundsCheck in tracked.currOptions:
-      tracked.canRaiseDefect = true
     if optStaticBoundsCheck in tracked.currOptions and n.len == 2:
       if n[0].typ != nil and skipTypes(n[0].typ, abstractVar).kind != tyTuple:
         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))
@@ -1719,7 +1505,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()
@@ -1736,8 +1522,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)
@@ -1786,18 +1570,13 @@ proc setEffectsForProcType*(g: ModuleGraph; t: PType, n: PNode; s: PSym = nil) =
     elif s != nil and (s.magic != mNone or {sfImportc, sfExportc} * s.flags == {sfImportc}):
       effects[exceptionEffects] = newNodeI(nkArgList, effects.info)
 
-    let forbidsSpec = effectSpec(n, wForbids)
     let tagsSpec = effectSpec(n, wTags)
     if not isNil(tagsSpec):
       effects[tagEffects] = tagsSpec
-    elif not isNil(forbidsSpec):
-      # `.forbids` without `.tags` still declares a known empty tag set.
-      # Leaving this as nil would mean "unknown tags", which later widens
-      # indirect calls to `RootEffect`.
-      effects[tagEffects] = newNodeI(nkArgList, effects.info)
     elif s != nil and (s.magic != mNone or {sfImportc, sfExportc} * s.flags == {sfImportc}):
       effects[tagEffects] = newNodeI(nkArgList, effects.info)
 
+    let forbidsSpec = effectSpec(n, wForbids)
     if not isNil(forbidsSpec):
       effects[forbiddenEffects] = forbidsSpec
     elif s != nil and (s.magic != mNone or {sfImportc, sfExportc} * s.flags == {sfImportc}):
@@ -1872,9 +1651,6 @@ proc trackProc*(c: PContext; s: PSym, body: PNode) =
 
   track(t, body)
 
-  if t.exc.len == 0 and not t.canRaiseDefect:
-    s.flags.incl sfNeverRaises
-
   if s.kind != skMacro:
     let params = s.typ.n
     for i in 1..<params.len:
@@ -1903,7 +1679,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:
@@ -617,7 +616,7 @@ proc checkDefineType(c: PContext; v: PSym; t: PType) =
     # no distinct types for generic define
     skipped.excl tyDistinct
   if t.skipTypes(skipped).kind notin typeKinds:
-    let name =
+    let name = 
       case v.magic
       of mStrDefine: "strdefine"
       of mIntDefine: "intdefine"
@@ -726,33 +725,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
@@ -1096,12 +1084,7 @@ proc symForVar(c: PContext, n: PNode): PSym =
 proc semForVars(c: PContext, n: PNode; flags: TExprFlags): PNode =
   result = n
   let iterBase = n[^2].typ
-  let iterType =
-    if iterBase.kind == tyIterable:
-      iterBase.skipModifier
-    else:
-      skipTypes(iterBase, {tyAlias, tySink, tyOwned})
-  var iter = skipTypes(iterType, {tyGenericInst})
+  var iter = skipTypes(iterBase, {tyGenericInst, tyAlias, tySink, tyOwned})
   var iterAfterVarLent = iter.skipTypes({tyGenericInst, tyAlias, tyLent, tyVar})
   # n.len == 3 means that there is one for loop variable
   # and thus no tuple unpacking:
@@ -1134,9 +1117,10 @@ proc semForVars(c: PContext, n: PNode; flags: TExprFlags): PNode =
       else:
         var v = symForVar(c, n[0])
         if getCurrOwner(c).kind == skModule: incl(v.flags, sfGlobal)
-        # Use `iterType` here: it removes outer `tyIterable` / alias-like wrappers
-        # from the loop source, but still preserves `tyGenericInst` for the loop var.
-        v.typ = iterType
+        # BUGFIX: don't use `iter` here as that would strip away
+        # the ``tyGenericInst``! See ``tests/compile/tgeneric.nim``
+        # for an example:
+        v.typ = iterBase
         n[0] = newSymNode(v)
         if sfGenSym notin v.flags and not isDiscardUnderscore(v): addDecl(c, v)
         elif v.owner == nil: setOwner(v, getCurrOwner(c))
@@ -1200,14 +1184,14 @@ proc semForVars(c: PContext, n: PNode; flags: TExprFlags): PNode =
   c.p.breakInLoop = oldBreakInLoop
   dec(c.p.nestedLoopCounter)
 
-proc implicitIterator(c: PContext, it: string, arg: PNode, flags: TExprFlags): PNode =
+proc implicitIterator(c: PContext, it: string, arg: PNode): PNode =
   result = newNodeI(nkCall, arg.info)
   result.add(newIdentNode(getIdent(c.cache, it), arg.info))
   if arg.typ != nil and arg.typ.kind in {tyVar, tyLent}:
     result.add newDeref(arg)
   else:
     result.add arg
-  result = semExprNoDeref(c, result, flags + {efWantIterator})
+  result = semExprNoDeref(c, result, {efWantIterator})
 
 proc isTrivalStmtExpr(n: PNode): bool =
   for i in 0..<n.len-1:
@@ -1293,8 +1277,7 @@ proc semFor(c: PContext, n: PNode; flags: TExprFlags): PNode =
   if result != nil: return result
   openScope(c)
   result = n
-  let iteratorFlags = flags * {efPreferIteratorForIterable}
-  n[^2] = semExprNoDeref(c, n[^2], iteratorFlags + {efWantIterator})
+  n[^2] = semExprNoDeref(c, n[^2], {efWantIterator})
   var call = n[^2]
 
   if call.kind == nkStmtListExpr and (isTrivalStmtExpr(call) or (call.lastSon.kind in nkCallKinds and call.lastSon[0].sym.kind == skIterator)):
@@ -1314,16 +1297,14 @@ proc semFor(c: PContext, n: PNode; flags: TExprFlags): PNode =
   elif not isCallExpr or call[0].kind != nkSym or
       call[0].sym.kind != skIterator:
     if n.len == 3:
-      n[^2] = implicitIterator(c, "items", n[^2], iteratorFlags)
+      n[^2] = implicitIterator(c, "items", n[^2])
     elif n.len == 4:
-      n[^2] = implicitIterator(c, "pairs", n[^2], iteratorFlags)
+      n[^2] = implicitIterator(c, "pairs", n[^2])
     else:
       localError(c.config, n[^2].info, "iterator within for loop context expected")
     result = semForVars(c, n, flags)
   else:
     result = semForVars(c, n, flags)
-  if n[^2].typ != nil and n[^2].typ.kind == tyIterable:
-    n[^2].typ = n[^2].typ.skipModifier
   # propagate any enforced VoidContext:
   if n[^1].typ == c.enforceVoidContext:
     result.typ() = c.enforceVoidContext
@@ -1787,23 +1768,6 @@ proc checkForMetaFields(c: PContext; n: PNode; hasError: var bool) =
     internalAssert c.config, false
 
 proc typeSectionFinalPass(c: PContext, n: PNode) =
-  # a son that still was a `tyForward` could not propagate `tfHasAsgn` and
-  # friends to its owner back then, see `rememberFlagUpdate`. Now that every
-  # forward declaration has a body, redo those propagations. They are recorded
-  # in declaration order rather than dependency order and an owner can itself
-  # be the son of another pair, so repeat until nothing changes; this
-  # terminates because flags are only ever added.
-  if c.forwardFlagUpdates.len > 0:
-    let updates = move c.forwardFlagUpdates
-    c.staleTypeFlags = initIntSet()
-    var changed = true
-    while changed:
-      changed = false
-      for (owner, elem) in updates:
-        let before = owner.flags
-        propagateToOwner(owner, elem)
-        if owner.flags != before: changed = true
-
   for i in 0..<n.len:
     var a = n[i]
     if a.kind == nkCommentStmt: continue
@@ -1853,13 +1817,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)
@@ -2128,54 +2085,47 @@ proc checkedForDestructor(t: PType): bool =
     return true
   result = false
 
-proc normalizeTypeHook(t: PType; markAsgn = false): PType =
+proc whereToBindTypeHook(c: PContext; t: PType): PType =
   result = t
   while true:
-    if markAsgn:
-      incl(result.flags, tfHasAsgn)
-    if result.kind == tyCompositeTypeClass and result.base.kind == tyGenericBody:
-      result = result.base
-    elif result.kind in {tyGenericBody, tyGenericInst}:
-      result = result.skipModifier
-    elif result.kind == tyGenericInvocation:
-      result = result.genericHead
-    else:
-      break
-
-proc whereToBindTypeHook(c: PContext; t: PType): PType =
-  result = normalizeTypeHook(t)
+    if result.kind in {tyGenericBody, tyGenericInst}: result = result.skipModifier
+    elif result.kind == tyGenericInvocation: result = result[0]
+    else: break
   if result.kind in {tyObject, tyDistinct, tySequence, tyString}:
     result = canonType(c, result)
 
-proc bindHookToType(c: PContext; s: PSym; n: PNode; op: TTypeAttachedOp;
-                    typeToBind: PType): bool =
-  var obj = typeToBind
-  if obj.kind notin {tyObject, tyDistinct, tySequence, tyString}:
-    return false
-  obj = canonType(c, obj)
-  let ao = getAttachedOp(c.graph, obj, op)
-  if ao == s:
-    discard "forward declared hook"
-  elif ao.isNil and not checkedForDestructor(obj):
-    setAttachedOp(c.graph, c.module.position, obj, op, s)
-  else:
-    prevDestructor(c, op, ao, obj, n.info)
-  if obj.owner.getModule != s.getModule:
-    localError(c.config, n.info, errGenerated,
-      "type bound operation `" & s.name.s & "` can be defined only in the same module with its type (" & obj.typeToString() & ")")
-  result = true
-
 proc bindDupHook(c: PContext; s: PSym; n: PNode; op: TTypeAttachedOp) =
   let t = s.typ
   var noError = false
   let cond = t.len == 2 and t.returnType != nil
 
   if cond:
-    var obj = normalizeTypeHook(t.firstParamType, markAsgn = true)
-    let res = normalizeTypeHook(t.returnType)
+    var obj = t.firstParamType
+    while true:
+      incl(obj.flags, tfHasAsgn)
+      if obj.kind in {tyGenericBody, tyGenericInst}: obj = obj.skipModifier
+      elif obj.kind == tyGenericInvocation: obj = obj.genericHead
+      else: break
 
-    if sameType(obj, res):
-      noError = bindHookToType(c, s, n, op, obj)
+    var res = t.returnType
+    while true:
+      if res.kind in {tyGenericBody, tyGenericInst}: res = res.skipModifier
+      elif res.kind == tyGenericInvocation: res = res.genericHead
+      else: break
+
+    if obj.kind in {tyObject, tyDistinct, tySequence, tyString} and sameType(obj, res):
+      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):
+        setAttachedOp(c.graph, c.module.position, obj, op, s)
+      else:
+        prevDestructor(c, op, ao, obj, n.info)
+      noError = true
+      if obj.owner.getModule != s.getModule:
+        localError(c.config, n.info, errGenerated,
+          "type bound operation `" & s.name.s & "` can be defined only in the same module with its type (" & obj.typeToString() & ")")
 
   if not noError and sfSystemModule notin s.owner.flags:
     localError(c.config, n.info, errGenerated,
@@ -2187,17 +2137,13 @@ proc bindDupHook(c: PContext; s: PSym; n: PNode; op: TTypeAttachedOp) =
 proc bindTypeHook(c: PContext; s: PSym; n: PNode; op: TTypeAttachedOp) =
   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
@@ -2205,15 +2151,35 @@ proc bindTypeHook(c: PContext; s: PSym; n: PNode; op: TTypeAttachedOp) =
                t.len >= 2 and t.returnType == nil
 
   if cond:
-    var obj = normalizeTypeHook(t.firstParamType.skipTypes({tyVar}), markAsgn = true)
-    noError = bindHookToType(c, s, n, op, obj)
+    var obj = t.firstParamType.skipTypes({tyVar})
+    while true:
+      incl(obj.flags, tfHasAsgn)
+      if obj.kind in {tyGenericBody, tyGenericInst}: obj = obj.skipModifier
+      elif obj.kind == tyGenericInvocation: obj = obj.genericHead
+      else: break
+    if obj.kind in {tyObject, tyDistinct, tySequence, tyString}:
+      if op == attachedDestructor and t.firstParamType.kind == tyVar and
+          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):
+        setAttachedOp(c.graph, c.module.position, obj, op, s)
+      else:
+        prevDestructor(c, op, ao, obj, n.info)
+      noError = true
+      if obj.owner.getModule != s.getModule:
+        localError(c.config, n.info, errGenerated,
+          "type bound operation `" & s.name.s & "` can be defined only in the same module with its type (" & obj.typeToString() & ")")
   if not noError and sfSystemModule notin s.owner.flags:
     case op
     of attachedTrace:
       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:
@@ -2273,12 +2239,35 @@ proc semOverride(c: PContext, s: PSym, n: PNode) =
       message(c.config, n.info, warnDeprecated, "Overriding `=` hook is deprecated; Override `=copy` hook instead")
     let t = s.typ
     if t.len == 3 and t.returnType == nil and t.firstParamType.kind == tyVar:
-      var obj = normalizeTypeHook(t.firstParamType.elementType, markAsgn = true)
-      let objB = normalizeTypeHook(t[2])
-      if sameType(obj, objB):
+      var obj = t.firstParamType.elementType
+      while true:
+        incl(obj.flags, tfHasAsgn)
+        if obj.kind == tyGenericBody: obj = obj.skipModifier
+        elif obj.kind == tyGenericInvocation: obj = obj.genericHead
+        else: break
+      var objB = t[2]
+      while true:
+        if objB.kind == tyGenericBody: objB = objB.skipModifier
+        elif objB.kind in {tyGenericInvocation, tyGenericInst}:
+          objB = objB.genericHead
+        else: break
+      if obj.kind in {tyObject, tyDistinct, tySequence, tyString} and sameType(obj, objB):
         # attach these ops to the canonical tySequence
+        obj = canonType(c, obj)
+        #echo "ATTACHING TO ", obj.id, " ", s.name.s, " ", cast[int](obj)
         let k = if name == "=" or name == "=copy": attachedAsgn else: attachedSink
-        if bindHookToType(c, s, n, k, obj): return
+        let ao = getAttachedOp(c.graph, obj, k)
+        if ao == s:
+          discard "forward declared op"
+        elif ao.isNil and not checkedForDestructor(obj):
+          setAttachedOp(c.graph, c.module.position, obj, k, s)
+        else:
+          prevDestructor(c, k, 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() & ")")
+
+        return
     if sfSystemModule notin s.owner.flags:
       localError(c.config, n.info, errGenerated,
                 "signature for '" & s.name.s & "' must be proc[T: object](x: var T; y: T)")
@@ -2527,9 +2516,6 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
   if not hasProto:
     implicitPragmas(c, s, n.info, validPragmas)
 
-  if {sfError, sfExportc} * s.flags == {sfError, sfExportc}:
-    localError(c.config, n.info, "{.error.} and {.exportc.} pragmas are incompatible")
-
   if n[pragmasPos].kind != nkEmpty and sfBorrow notin s.flags:
     setEffectsForProcType(c.graph, s.typ, n[pragmasPos], s)
   s.typ.flags.incl tfEffectSystemWorkaround
@@ -2590,11 +2576,6 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
       elif s.name.s == "()" and callOperator notin c.features:
         localError(c.config, n.info, "the overloaded " & s.name.s &
           " operator has to be enabled with {.experimental: \"callOperator\".}")
-    elif sfImportc notin s.flags and (s.name.s == ">" or s.name.s == ">=" or s.name.s == "!="):
-      # ignore imported procs as these operators in backend language might have different semantics
-      let op1 = if s.name.s == "!=": "==" elif s.name.s == ">": "<" else: "<="
-      message(c.config, n.info, warnInvalidCmpOp, "define `" & op1 & "` instead of `" & s.name.s & "` to implement user defined comparison operator. " &
-              "it allows you to use `" & s.name.s & "` automatically.")
 
   if sfBorrow in s.flags and c.config.cmd notin cmdDocLike:
     result[bodyPos] = c.graph.emptyNode
@@ -2635,18 +2616,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):
@@ -2832,24 +2804,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
@@ -2874,20 +2831,16 @@ 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()
-  let oldErrorCount = c.config.errorCounter
   inc c.inStaticContext
   openScope(c)
   let a = semStmt(c, n[0], {})
   closeScope(c)
   dec c.inStaticContext
   n[0] = a
-  if c.config.errorCounter == oldErrorCount:
-    evalStaticStmt(c.module, c.idgen, c.graph, a, c.p.owner)
+  evalStaticStmt(c.module, c.idgen, c.graph, a, c.p.owner)
   when false:
     # for incremental replays, keep the AST as required for replays:
     result = n

compiler/semtempl.nim

@@ -67,9 +67,12 @@ 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)
+      if isField:
+        # possibly not final field sym
+        incl(s.flags, sfUsed)
+        markOwnerModuleAsUsed(c, s)
+      else:
+        markUsed(c, info, s)
       onUse(info, s)
     else:
       result = n

compiler/semtypes.nim

@@ -38,39 +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 rememberFlagUpdate(c: PContext; owner, elem: PType) =
-  ## `propagateToOwner` just derived `owner`'s `tfHasAsgn` & friends from
-  ## `elem`, but inside a type section `elem` can still be an unreified
-  ## `tyForward` which has nothing to derive from yet -- and a type that read
-  ## such a type is provisional in turn. Remember the pair so
-  ## `typeSectionFinalPass` can redo the propagation once every forward
-  ## declaration has a body, the same way `forwardFieldUpdates` defers the
-  ## field defaults.
-  if elem != nil and (elem.kind == tyForward or elem.id in c.staleTypeFlags):
-    c.forwardFlagUpdates.add (owner, elem)
-    c.staleTypeFlags.incl owner.id
 
 proc newConstraint(c: PContext, k: TTypeKind): PType =
   result = newTypeS(tyBuiltInTypeClass, c)
@@ -211,11 +193,9 @@ proc semSet(c: PContext, n: PNode, prev: PType): PType =
   result = newOrPrevType(tySet, prev, c)
   if n.len == 2 and n[1].kind != nkEmpty:
     var base = semTypeNode(c, n[1], nil)
-    if base.kind == tyTypeDesc: base = base.base  # unwrap from type traits like distinctBase
     addSonSkipIntLit(result, base, c.idgen)
-    rememberFlagUpdate(c, result, base)
     if base.kind in {tyGenericInst, tyAlias, tySink}: base = skipModifier(base)
-    if base.kind notin {tyGenericParam, tyGenericInvocation, tyFromExpr}:
+    if base.kind notin {tyGenericParam, tyGenericInvocation}:
       if base.kind == tyForward:
         c.skipTypes.add n
       elif not isOrdinalType(base, allowEnumWithHoles = true):
@@ -232,7 +212,6 @@ proc semContainerArg(c: PContext; n: PNode, kindStr: string; result: PType) =
     if base.kind == tyVoid:
       localError(c.config, n.info, errTIsNotAConcreteType % typeToString(base))
     addSonSkipIntLit(result, base, c.idgen)
-    rememberFlagUpdate(c, result, base)
   else:
     localError(c.config, n.info, errXExpectsOneTypeParam % kindStr)
     addSonSkipIntLit(result, errorType(c), c.idgen)
@@ -325,7 +304,6 @@ proc addSonSkipIntLitChecked(c: PContext; father, son: PType; it: PNode, id: IdG
     localError(c.config, it.info, "illegal recursion in type '" & typeToString(s) & "'")
   else:
     propagateToOwner(father, s)
-    rememberFlagUpdate(c, father, s)
 
 proc semDistinct(c: PContext, n: PNode, prev: PType): PType =
   if n.len == 0: return newConstraint(c, tyDistinct)
@@ -490,7 +468,6 @@ proc semArray(c: PContext, n: PNode, prev: PType): PType =
     # index type:
     result = newOrPrevType(tyArray, prev, c, indx)
     addSonSkipIntLit(result, base, c.idgen)
-    rememberFlagUpdate(c, result, base)
   else:
     localError(c.config, n.info, errArrayExpectsTwoTypeParams)
     result = newOrPrevType(tyError, prev, c)
@@ -550,7 +527,7 @@ proc semTuple(c: PContext, n: PNode, prev: PType): PType =
           typ = a[^1].typ
       else:
         fitDefaultNode(c, a[^1], typ)
-        typ = a[^1].typ.skipIntLit(c.idgen)
+        typ = a[^1].typ
     elif a[^2].kind != nkEmpty:
       typ = semTypeNode(c, a[^2], nil)
       if c.graph.config.isDefined("nimPreviewRangeDefault") and typ.skipTypes(abstractInst).kind == tyRange:
@@ -573,11 +550,10 @@ proc semTuple(c: PContext, n: PNode, prev: PType): PType =
           fSym.sym.ast.flags.incl nfSkipFieldChecking
         result.n.add fSym
         addSonSkipIntLit(result, typ, c.idgen)
-        rememberFlagUpdate(c, result, typ)
       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,
@@ -808,7 +784,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:
@@ -816,8 +792,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")
@@ -923,7 +898,7 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var IntSet, pos: var int,
           typ = n[^1].typ
       else:
         fitDefaultNode(c, n[^1], typ)
-        typ = n[^1].typ.skipIntLit(c.idgen)
+        typ = n[^1].typ
         propagateToOwner(rectype, typ)
     elif n[^2].kind == nkEmpty:
       localError(c.config, n.info, errTypeExpected)
@@ -934,7 +909,6 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var IntSet, pos: var int,
         n[^1] = firstRange(c.config, typ)
         hasDefaultField = true
       propagateToOwner(rectype, typ)
-      rememberFlagUpdate(c, rectype, typ)
     var fieldOwner = if c.inGenericContext > 0: c.getCurrOwner
                      else: rectype.sym
     for i in 0..<n.len-2:
@@ -1005,7 +979,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:
@@ -1057,7 +1031,6 @@ proc semObjectNode(c: PContext, n: PNode, prev: PType; flags: TTypeFlags): PType
   if n.kind != nkObjectTy: internalError(c.config, n.info, "semObjectNode")
   result = newOrPrevType(tyObject, prev, c)
   rawAddSon(result, realBase)
-  rememberFlagUpdate(c, result, realBase)
   if realBase == nil and tfInheritable in flags:
     result.flags.incl tfInheritable
   if tfAcyclic in flags: result.flags.incl tfAcyclic
@@ -1129,9 +1102,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 =
@@ -1184,15 +1155,7 @@ proc addImplicitGeneric(c: PContext; typeClass: PType, typId: PIdent;
   # is this a bindOnce type class already present in the param list?
   for i in 0..<genericParams.len:
     if genericParams[i].sym.name.id == finalTypId.id:
-      if typeClass.kind == tyStatic and genericParams[i].typ.kind != tyStatic:
-        # The base type (e.g. from `auto`) was already added as a generic param,
-        # but `static[auto]` requires upgrading it to a `tyStatic` wrapper so
-        # it is instantiated as a compile-time value (`skConst`).
-        genericParams[i].sym.linkTo(typeClass)
-        typeClass.flags.incl tfImplicitTypeParam
-        return typeClass
-      else:
-        return genericParams[i].typ
+      return genericParams[i].typ
 
   let owner = if typeClass.sym != nil: typeClass.sym
               else: getCurrOwner(c)
@@ -1326,14 +1289,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
@@ -1347,6 +1308,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)
@@ -1503,8 +1465,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
 
@@ -1568,9 +1528,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")
@@ -1757,7 +1715,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:
@@ -1778,10 +1736,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)
@@ -1969,90 +1927,34 @@ proc semStaticType(c: PContext, childNode: PNode, prev: PType): PType =
   result.rawAddSon(base)
   result.flags.incl tfHasStatic
 
-proc semTypeOfImpl(c: PContext; n: PNode): PNode =
-  var m = BiggestInt 1 # typeOfIter
-  var modifierMode = BiggestInt 0 # CompatibleTypeModifiers
-  type
-    TypeOfParams = enum
-      topMode
-      topModifier
-  if n.len in 3 .. 4:
-    for i in 2 ..< n.len:
-      var argKind = topMode
-      var arg: PNode = nil
-      if n[i].kind == nkExprEqExpr and n[i][0].kind == nkIdent:
-        # named param
-        case n[i][0].ident.s
-        of "mode": argKind = topMode
-        of "modifierMode": argKind = topModifier
-        else:
-          localError(c.config, n.info, "typeof: got unknown parameter name")
-        arg = n[i][1]
-      else:
-        if i == 2:
-          argKind = topMode
-        else:
-          argKind = topModifier
-        arg = n[i]
-      case argKind
-      of topMode:
-        let mode = semConstExpr(c, arg)
-        if mode.kind != nkIntLit:
-          localError(c.config, n.info, "typeof: cannot evaluate 'mode' parameter at compile-time")
-        else:
-          m = mode.intVal
-      of topModifier:
-        let modMode = semConstExpr(c, arg)
-        if modMode.kind != nkIntLit:
-          localError(c.config, n.info, "typeof: cannot evaluate 'modifierMode' parameter at compile-time")
-        else:
-          modifierMode = modMode.intVal
-
-  inc c.inTypeofContext
-  defer: dec c.inTypeofContext # compiles can raise an exception
-  var typExpr = semExprNoDeref(c, n[1], if m == 1: {efInTypeof} else: {})
-  if modifierMode == 0:
-    # CompatibleTypeModifiers
-    typExpr.typ = typExpr.typ.skipTypes({tyVar, tyLent})
-  elif modifierMode == 1:
-    # RemoveTypeModifiers
-    typExpr.typ = typExpr.typ.skipTypes({tyVar, tyLent, tySink})
-
-  result = typExpr
-
 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)
-  let ex = semTypeOfImpl(c, n)
+  var m = BiggestInt 1 # typeOfIter
+  if n.len == 3:
+    let mode = semConstExpr(c, n[2])
+    if mode.kind != nkIntLit:
+      localError(c.config, n.info, "typeof: cannot evaluate 'mode' parameter at compile-time")
+    else:
+      m = mode.intVal
+  inc c.inTypeofContext
+  defer: dec c.inTypeofContext # compiles can raise an exception
+  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:
@@ -2076,9 +1978,7 @@ proc semTypeIdent(c: PContext, n: PNode): PSym =
         # proc signature for example
         if c.inGenericInst > 0:
           let bound = result.typ.elementType.sym
-          # the symbol may still point to the uninstantiated generic body type
-          if bound != nil and bound.typ == result.typ.elementType:
-            return bound
+          if bound != nil: return bound
           return result
         if result.typ.sym == nil:
           localError(c.config, n.info, errTypeExpected)
@@ -2229,9 +2129,6 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
         result = semAnyRef(c, n, tyPtr, prev)
       elif op.id == ord(wRef):
         result = semAnyRef(c, n, tyRef, prev)
-      elif op.id == ord(wStatic):
-        checkSonsLen(n, 2, c.config)
-        result = semStaticType(c, n[1], prev)
       elif op.id == ord(wType):
         checkSonsLen(n, 2, c.config)
         result = semTypeOf(c, n[1], prev)
@@ -2251,8 +2148,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))
@@ -2270,21 +2166,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:
@@ -2294,11 +2179,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}:
@@ -2329,7 +2212,7 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
     else:
       result = typeExpr.typ.base
       if result.isMetaType and
-         result.kind notin tyTypeClasses:
+         result.kind != tyUserTypeClass:
            # the dot expression may refer to a concept type in
            # a different module. allow a normal alias then.
         let preprocessed = semGenericStmt(c, n)

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
@@ -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
@@ -291,7 +280,7 @@ proc replaceTypeVarsN(cl: var TReplTypeVars, n: PNode; start=0; expectedType: PT
         (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)
+      result.sym.typ = result.sym.ast.typ
     # sym type can be nil if was gensym created by macro, see #24048
     if result.sym.typ != nil and result.sym.typ.kind == tyVoid:
       # don't add the 'void' field
@@ -562,26 +551,6 @@ proc eraseVoidParams*(t: PType) =
       setLen t.n.sons, pos
       break
 
-proc eraseTupleVoidFields*(t: PType) =
-  ## Remove void fields from a named tuple type, compacting both `t.n`
-  ## (the field symbol nodes) and `t.sonsImpl` (the child types).
-  if t.n == nil: return  # anonymous tuple, nothing to compact
-  for i in 0..<t.kidsLen:
-    if t.n[i].kind == nkRecList or t[i].kind == tyVoid:
-      # found first void field, compact from here
-      var pos = i
-      for j in i+1..<t.kidsLen:
-        if t[j].kind != tyVoid and j < t.n.len and t.n[j].kind != nkRecList:
-          t.n[pos] = t.n[j]
-          t[pos] = t[j]
-          if t.n[pos].kind == nkSym:
-            t.n[pos].sym.position = pos
-          inc pos
-        # else: skip void entries
-      setLen t.n.sons, pos
-      t.setSonsLen pos
-      break
-
 proc skipIntLiteralParams*(t: PType; idgen: IdGenerator) =
   for i, p in t.ikids:
     if p == nil: continue
@@ -639,13 +608,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
@@ -713,7 +679,7 @@ proc replaceTypeVarsTAux(cl: var TReplTypeVars, t: PType, isInstValue = false):
 
   of tyUserTypeClass:
     result = t
-
+  
   of tyStatic:
     if cl.c.matchedConcept != nil:
       # allow concepts to not instantiate statics for now
@@ -786,8 +752,6 @@ proc replaceTypeVarsTAux(cl: var TReplTypeVars, t: PType, isInstValue = false):
         propagateFieldFlags(result, result.n)
         if result.kind == tyObject and cl.c.computeRequiresInit(cl.c, result):
           result.flags.incl tfRequiresInit
-        if result.kind == tyTuple:
-          eraseTupleVoidFields(result)
 
       of tyProc:
         eraseVoidParams(result)

compiler/sighashes.nim

@@ -41,7 +41,6 @@ type
     CoType
     CoOwnerSig
     CoIgnoreRange
-    CoIgnoreRangeInArray
     CoConsiderOwned
     CoDistinct
     CoHashTypeInsideNode
@@ -137,17 +136,12 @@ proc hashType(c: var MD5Context, t: PType; flags: set[ConsiderFlag]; conf: Confi
     if CoConsiderOwned in flags:
       c &= char(t.kind)
     c.hashType t.skipModifier, flags, conf
-  of tyBool, tyChar, tyPointer, tyCstring, tyInt..tyUInt64:
-    # no canonicalization for builtin scalar-ish / pointer-like types, so
-    # that e.g. ``pid_t`` or an imported ``pointer`` alias keep their
-    # backend spelling instead of collapsing into the generic Nim builtin:
+  of tyBool, tyChar, tyInt..tyUInt64:
+    # no canonicalization for integral types, so that e.g. ``pid_t`` is
+    # produced instead of ``NI``:
     c &= char(t.kind)
     if t.sym != nil and {sfImportc, sfExportc} * t.sym.flags != {}:
-      # Aliases inherit the external name, but have a different symbol.
-      if t.sym.loc.snippet != "":
-        c &= t.sym.loc.snippet
-      else:
-        c.hashSym(t.sym)
+      c.hashSym(t.sym)
   of tyObject, tyEnum:
     if t.typeInst != nil:
       # prevent against infinite recursions here, see bug #8883:
@@ -156,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)
@@ -212,7 +206,6 @@ proc hashType(c: var MD5Context, t: PType; flags: set[ConsiderFlag]; conf: Confi
     c.hashTree(t.n, {}, conf)
   of tyTuple:
     c &= char(t.kind)
-    c &= t.len
     if t.n != nil and CoType notin flags:
       for i in 0..<t.n.len:
         assert(t.n[i].kind == nkSym)
@@ -223,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)
@@ -263,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)
@@ -448,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,
@@ -46,8 +45,7 @@ type
 
   TCandidate* = object
     c*: PContext
-    exactMatches*: int
-    iteratorPreference*: int # prefer iterators in iterator-oriented contexts
+    exactMatches*: int       # also misused to prefer iters over procs
     genericMatches: int      # also misused to prefer constraints
     subtypeMatches: int
     intConvMatches: int      # conversions to int are not as expensive
@@ -96,7 +94,6 @@ type
     trNoCovariance
     trBindGenericParam  # bind tyGenericParam even with trDontBind
     trIsOutParam
-    trCheckGeneric
 
   TTypeRelFlags* = set[TTypeRelFlag]
 
@@ -105,14 +102,13 @@ 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,
                       callee: PType): TCandidate {.inline.} =
   result = TCandidate(c: ctx, exactMatches: 0, subtypeMatches: 0,
-                      iteratorPreference: 0, convMatches: 0, intConvMatches: 0,
-                      genericMatches: 0,
+                      convMatches: 0, intConvMatches: 0, genericMatches: 0,
                       state: csEmpty, firstMismatch: MismatchInfo(),
                       callee: callee, call: nil, baseTypeMatch: false,
                       genericConverter: false, inheritancePenalty: -1
@@ -162,7 +158,8 @@ proc matchGenericParam(m: var TCandidate, formal: PType, n: PNode) =
       arg = newTypeS(tyStatic, m.c, son = evaluated.typ)
       arg.n = evaluated
   elif formalBase.kind == tyTypeDesc:
-    discard # if arg is not tyTypeDesc, typeRel will report the mismatch
+    if arg.kind != tyTypeDesc:
+      arg = makeTypeDesc(m.c, arg)
   else:
     arg = arg.skipTypes({tyTypeDesc})
   let tm = typeRel(m, formal, arg)
@@ -300,9 +297,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
@@ -366,8 +363,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 =
@@ -397,7 +392,6 @@ proc complexDisambiguation(a, b: PType): int =
 proc writeMatches*(c: TCandidate) =
   echo "Candidate '", c.calleeSym.name.s, "' at ", c.c.config $ c.calleeSym.info
   echo "  exact matches: ", c.exactMatches
-  echo "  iterator preference: ", c.iteratorPreference
   echo "  generic matches: ", c.genericMatches
   echo "  subtype matches: ", c.subtypeMatches
   echo "  intconv matches: ", c.intConvMatches
@@ -416,8 +410,6 @@ proc cmpInheritancePenalty(a, b: int): int =
 proc cmpCandidates*(a, b: TCandidate, isFormal=true): int =
   result = a.exactMatches - b.exactMatches
   if result != 0: return
-  result = a.iteratorPreference - b.iteratorPreference
-  if result != 0: return
   result = a.genericMatches - b.genericMatches
   if result != 0: return
   result = a.subtypeMatches - b.subtypeMatches
@@ -621,8 +613,6 @@ proc isGenericObjectOf(f, a: PType): bool =
   # 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
@@ -786,19 +776,6 @@ proc procParamTypeRel(c: var TCandidate; f, a: PType): TTypeRelation =
     # if f is metatype.
     result = typeRel(c, f, a)
 
-  if result == isEqual and
-      procParamTypeBackendAliases notin c.c.config.legacyFeatures:
-    # Ensure types that are semantically equal also match at the backend level.
-    # E.g. reject assigning proc(csize_t) to proc(uint) since these map to
-    # different C types (size_t vs unsigned long long).
-    let fCheck = concreteType(c, f)
-    let aCheck = concreteType(c, a)
-    # Note that `result` is equal; now check whether they have the same
-    # backend type.
-    if fCheck != nil and aCheck != nil and
-      not sameBackendTypePickyAliases(fCheck, aCheck, {IgnoreFlags}):
-      result = isNone
-
   if result <= isSubrange or inconsistentVarTypes(f, a):
     result = isNone
 
@@ -1161,30 +1138,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
-  # considerPreviousT-like behavior
-  let prev = lookup(c.bindings, concpt)
-  if prev != nil:
-    return typeRel(c, prev, a, flags)
-  if trDontBind in flags:
-    conceptFlags.incl mfDontBind
-  if trBindGenericParam in flags:
-    conceptFlags.incl mfBindGenericParam
-  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})
@@ -1259,10 +1212,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
@@ -1472,8 +1424,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:
@@ -1566,14 +1517,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})
@@ -1593,11 +1542,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:
@@ -1697,11 +1643,10 @@ 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
 
@@ -1713,7 +1658,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)
@@ -1724,36 +1669,35 @@ 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:
+              inc c.inheritancePenalty, 1 + int(c.inheritancePenalty < 0)
+            let ret = typeRel(c, f, baseType, flags)
+            return if ret in {isEqual,isGeneric}: isSubtype else: ret
 
-      if aAsObject.kind == tyObject and trIsOutParam notin flags:
-        let baseType = aAsObject.base
-        if baseType != nil:
-          if tfFinal notin aAsObject.flags:
-            inc c.inheritancePenalty, 1 + int(c.inheritancePenalty < 0)
-          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)
@@ -1766,26 +1710,11 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
       let ff = last(f)
       if ff != nil:
         result = typeRel(c, ff, a, flags)
-      if result == isNone and a.kind == tyGenericInst and trBindGenericParam in flags:
-        var depth = -1
-        # Generic-parameter constraints like `F: Future` can miss in `last(f)`
-        # when the actual type inherits from a concrete generic instantiation.
-        # Keep this fallback scoped to generic-parameter matching so typedesc
-        # overloads such as `type Future[T]` still prefer more specific
-        # descendants like `InternalRaisesFuture[T, E]`.
-        if isGenericSubtype(c, a, f, depth, f) and depth > 0:
-          var askip = skippedNone
-          let aobj = a.skipToObject(askip)
-          if aobj != nil and tfFinal notin aobj.flags:
-            # Keep overload ranking consistent with other inheritance-based
-            # matches: deeper descendants are slightly worse candidates.
-            inc c.inheritancePenalty, depth + int(c.inheritancePenalty < 0)
-          result = isGeneric
   of tyGenericInvocation:
     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
@@ -1818,8 +1747,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
@@ -1827,7 +1757,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:
         #
@@ -1891,10 +1821,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:
@@ -1956,7 +1885,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
@@ -2085,18 +2018,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
               result = typeRel(c, f.base, a, flags)
         else:
           result = isGeneric
-        if result != isNone:
-          if f.base.kind notin {tyNone, tyGenericParam} and
-              aOrig.kind == tyStatic and aOrig.n != nil and aOrig.n.typ != nil and
-              aOrig.n.typ.isEmptyContainer:
-            # we need to infer the inner type for empty containers
-            let literal = aOrig.n.copyTree
-            literal.typ = f.base
-            let staticArg = newTypeS(tyStatic, c.c, f.base)
-            staticArg.n = literal
-            put(c, f, staticArg)
-          else:
-            put(c, f, aOrig)
+        if result != isNone: put(c, f, aOrig)
       elif aOrig.n != nil and aOrig.n.typ != nil:
         result = if f.base.kind != tyNone:
                    typeRel(c, f.last, aOrig.n.typ, flags)
@@ -2236,11 +2158,9 @@ proc implicitConv(kind: TNodeKind, f: PType, arg: PNode, m: TCandidate,
       result.typ() = errorType(c)
   else:
     result.typ() = f.skipTypes({tySink})
-  # keep varness, but don't wrap lent types with var
+  # keep varness
   if arg.typ != nil and arg.typ.kind == tyVar:
-    result.typ() = toVar(result.typ.skipTypes({tyLent}), tyVar, c.idgen)
-    # copy the tfVarIsPtr flag
-    result.typ.flags = arg.typ.flags
+    result.typ() = toVar(result.typ, tyVar, c.idgen)
   else:
     result.typ() = result.typ.skipTypes({tyVar})
 
@@ -2350,8 +2270,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``
@@ -2363,7 +2282,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
@@ -2379,8 +2298,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)
@@ -2492,6 +2410,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:
@@ -2506,10 +2425,6 @@ proc paramTypesMatchAux(m: var TCandidate, f, a: PType,
       return arg
     elif f.kind == tyStatic and arg.typ.n != nil:
       return arg.typ.n
-    elif f.kind == tyUntyped:
-      # bug #25693: a different overload candidate may have sem-checked the
-      # operand and left symbols behind; templates expect the pristine AST.
-      return argOrig
     else:
       return argSemantized # argOrig
 
@@ -2803,8 +2718,7 @@ proc prepareOperand(c: PContext; formal: PType; a: PNode, newlyTyped: var bool):
     result = a
   elif a.typ.isNil:
     if formal.kind == tyIterable:
-      let flags = {efDetermineType, efAllowStmt, efWantIterator, efWantIterable,
-                   efPreferIteratorForIterable}
+      let flags = {efDetermineType, efAllowStmt, efWantIterator, efWantIterable}
       result = c.semOperand(c, a, flags)
     else:
       # XXX This is unsound! 'formal' can differ from overloaded routine to
@@ -2821,20 +2735,6 @@ proc prepareOperand(c: PContext; formal: PType; a: PNode, newlyTyped: var bool):
     considerGenSyms(c, result)
     if result.kind != nkHiddenDeref and result.typ.kind in {tyVar, tyLent} and c.matchedConcept == nil:
       result = newDeref(result)
-    # Recovery for calls resolved too early as non-iterators.
-    # TODO: retry only skIterator overloads instead of re-semming,
-    # or preserve iterator-candidates info from the earlier semcheck.
-    if formal.kind == tyIterable and result.typ.kind != tyIterable and
-        a.kind in nkCallKinds and a[0].kind in {nkIdent, nkAccQuoted, nkSym, nkOpenSym}:
-      let recheck = copyTree(a)
-      recheck.typ = nil
-      if recheck[0].kind == nkSym and recheck[0].sym != nil:
-        recheck[0] = newIdentNode(recheck[0].sym.name, recheck[0].info)
-      let flags = {efDetermineType, efAllowStmt, efNoUndeclared,
-                   efWantIterator, efWantIterable, efPreferIteratorForIterable}
-      let fresh = c.semOperand(c, recheck, flags)
-      if fresh.typ != nil and fresh.typ.kind == tyIterable:
-        return fresh
 
 proc prepareOperand(c: PContext; a: PNode, newlyTyped: var bool): PNode =
   if a.typ.isNil:
@@ -2884,12 +2784,9 @@ proc findFirstArgBlock(m: var TCandidate, n: PNode): int =
     else: break
 
 proc matchesAux(c: PContext, n, nOrig: PNode, m: var TCandidate, marker: var IntSet) =
+
   template noMatch() =
-    if m.calleeSym != nil and m.calleeSym.kind notin {skTemplate, skMacro}:
-      c.mergeShadowScope
-    else:
-      c.rememberShadowDefs
-      c.closeShadowScope
+    c.mergeShadowScope #merge so that we don't have to resem for later overloads
     m.state = csNoMatch
     m.firstMismatch.arg = a
     m.firstMismatch.formal = formal
@@ -2945,10 +2842,7 @@ proc matchesAux(c: PContext, n, nOrig: PNode, m: var TCandidate, marker: var Int
           setSon(m.call, formal.position + 1, container)
         else:
           incrIndexType(container.typ)
-        # bug #25693: like the scalar `tyUntyped` case in `paramTypesMatchAux`,
-        # a previous overload candidate may have sem-checked the operand in
-        # place; templates/macros expect the pristine AST, so use `nOrig`.
-        container.add nOrig[a]
+        container.add n[a]
     elif n[a].kind == nkExprEqExpr:
       # named param
       m.firstMismatch.kind = kUnknownNamedParam
@@ -3047,8 +2941,7 @@ proc matchesAux(c: PContext, n, nOrig: PNode, m: var TCandidate, marker: var Int
             setSon(m.call, formal.position + 1, container)
           else:
             incrIndexType(container.typ)
-          # bug #25693: see the leading isVarargsUntyped branch above.
-          container.add nOrig[a]
+          container.add n[a]
         else:
           m.baseTypeMatch = false
           m.typedescMatched = false
@@ -3100,7 +2993,6 @@ proc matchesAux(c: PContext, n, nOrig: PNode, m: var TCandidate, marker: var Int
     if m.state == csMatch and not (m.calleeSym != nil and m.calleeSym.kind in {skTemplate, skMacro}):
       c.mergeShadowScope
     else:
-      c.rememberShadowDefs
       c.closeShadowScope
 
     inc a
@@ -3171,7 +3063,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/sizealignoffsetimpl.nim

@@ -394,10 +394,9 @@ proc computeSizeAlign(conf: ConfigRef; typ: PType) =
           accum.offset = 1
         computeObjectOffsetsFoldFunction(conf, typ.n, false, accum)
       let paddingAtEnd = int16(accum.finish())
-      if (typ.sym != nil and
-          typ.sym.flags * {sfCompilerProc, sfImportc} == {sfImportc} and
-          tfCompleteStruct notin typ.flags) or
-         tfIncompleteStruct in typ.flags:
+      if typ.sym != nil and
+         typ.sym.flags * {sfCompilerProc, sfImportc} == {sfImportc} and
+         tfCompleteStruct notin typ.flags:
         typ.size = szUnknownSize
         typ.align = szUnknownSize
         typ.paddingAtEnd = szUnknownSize

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

@@ -22,7 +22,7 @@ import std / tables
 
 import
   options, ast, astalgo, trees, msgs,
-  idents, renderer, types, semfold, magicsys, cgmeth, parampatterns,
+  idents, renderer, types, semfold, magicsys, cgmeth,
   lowerings, liftlocals,
   modulegraphs, lineinfos
 
@@ -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
@@ -92,21 +92,11 @@ proc getCurrOwner(c: PTransf): PSym =
   if c.transCon != nil: result = c.transCon.owner
   else: result = c.module
 
-proc freshOwnedSym(c: PTransf; s, owner: PSym): PNode =
-  # We need to copy the symbol here because we might need to change its owner and
-  # we don't want to mess with the original symbol which might be used in other places.
-  # This can happen for example for iterators which are transformed multiple times when
-  # they are used in different contexts.
-  var fresh = copySym(s, c.idgen)
-  if fresh.kind notin routineKinds:
-    incl(fresh.flags, sfFromGeneric)
-  setOwner(fresh, owner)
-  result = newSymNode(fresh)
-
 proc newTemp(c: PTransf, typ: PType, info: TLineInfo): PNode =
   let r = newSym(skTemp, getIdent(c.graph.cache, genPrefix), c.idgen, getCurrOwner(c), info)
   r.typ = typ #skipTypes(typ, {tyGenericInst, tyAlias, tySink})
   incl(r.flags, sfFromGeneric)
+  let owner = getCurrOwner(c)
   result = newSymNode(r)
 
 proc transform(c: PTransf, n: PNode, noConstFold = false): PNode
@@ -130,24 +120,6 @@ proc newAsgnStmt(c: PTransf, kind: TNodeKind, le: PNode, ri: PNode; isFirstWrite
     le.flags.incl nfFirstWrite
   result[1] = ri
 
-proc resolveBorrowedRoutineSym(c: PTransf; s: PSym; info: TLineInfo): PSym =
-  # Follow borrow aliases to the underlying implementation symbol.
-  var s = s
-  while true:
-    # Skips over all borrowed procs getting the last proc symbol without an implementation
-    let body = getBody(c.graph, s)
-    if body.kind == nkSym and sfBorrow in body.sym.flags and getBody(c.graph, body.sym).kind == nkSym:
-      s = body.sym
-    else:
-      break
-
-  let body = getBody(c.graph, s)
-  if body.kind == nkSym:
-    result = body.sym
-  else:
-    result = nil
-    internalError(c.graph.config, info, "wrong AST for borrowed symbol")
-
 proc transformSymAux(c: PTransf, n: PNode): PNode =
   let s = n.sym
   if s.typ != nil and s.typ.callConv == ccClosure:
@@ -166,7 +138,17 @@ proc transformSymAux(c: PTransf, n: PNode): PNode =
   var tc = c.transCon
   if sfBorrow in s.flags and s.kind in routineKinds:
     # simply exchange the symbol:
-    b = newSymNode(resolveBorrowedRoutineSym(c, s, n.info), n.info)
+    var s = s
+    while true:
+      # Skips over all borrowed procs getting the last proc symbol without an implementation
+      let body = getBody(c.graph, s)
+      if body.kind == nkSym and sfBorrow in body.sym.flags and getBody(c.graph, body.sym).kind == nkSym:
+        s = body.sym
+      else:
+        break
+    b = getBody(c.graph, s)
+    if b.kind != nkSym: internalError(c.graph.config, n.info, "wrong AST for borrowed symbol")
+    b = newSymNode(b.sym, n.info)
   elif c.inlining > 0:
     # see bug #13596: we use ref-based equality in the DFA for destruction
     # injections so we need to ensure unique nodes after iterator inlining
@@ -197,39 +179,11 @@ proc transformSym(c: PTransf, n: PNode): PNode =
   result = transformSymAux(c, n)
 
 proc freshVar(c: PTransf; v: PSym): PNode =
-  result = freshOwnedSym(c, v, getCurrOwner(c))
-
-proc introduceNewRoutineHeaderSyms(c: PTransf; n: PNode; oldOwner, newOwner: PSym) =
-  # We need to introduce new symbols for the parameters and result of a routine when
-  # we copy it for inlining or closure generation.
-  # Otherwise, we would have multiple nodes referring to the same parameter symbols which
-  # can lead to problems when we need to change the owner of these symbols.
-  case n.kind
-  of nkSym:
-    if n.sym.owner == oldOwner:
-      c.transCon.mapping[n.sym.itemId] = freshOwnedSym(c, n.sym, newOwner)
-  of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit:
-    discard
-  else:
-    for i in 0..<n.len:
-      introduceNewRoutineHeaderSyms(c, n[i], oldOwner, newOwner)
-
-proc copyRoutineTypeHeader(c: PTransf; oldProc, newProc: PSym) =
-  # We need to copy the routine type header to ensure that
-  # modifications to the newProc do not affect the oldProc.
-  if oldProc.typ != nil and oldProc.typ.kind == tyProc and oldProc.typ.n != nil:
-    newProc.typ = copyType(oldProc.typ, c.idgen, newProc)
-    newProc.typ.n = newNodeI(oldProc.typ.n.kind, oldProc.typ.n.info)
-    if oldProc.typ.n.len > 0:
-      newProc.typ.n.add copyTree(oldProc.typ.n[0])
-      for i in 1..<oldProc.typ.n.len:
-        let oldParam = oldProc.typ.n[i].sym
-        var newParam = getOrDefault(c.transCon.mapping, oldParam.itemId)
-        if newParam == nil:
-          newParam = freshOwnedSym(c, oldParam, newProc)
-          c.transCon.mapping[oldParam.itemId] = newParam
-        doAssert newParam.kind == nkSym
-        newProc.typ.addParam newParam.sym
+  let owner = getCurrOwner(c)
+  var newVar = copySym(v, c.idgen)
+  incl(newVar.flags, sfFromGeneric)
+  setOwner(newVar, owner)
+  result = newSymNode(newVar)
 
 proc transformVarSection(c: PTransf, v: PNode): PNode =
   result = newTransNode(v)
@@ -305,8 +259,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:
@@ -375,20 +328,13 @@ proc introduceNewLocalVars(c: PTransf, n: PNode): PNode =
     if a.kind == nkSym:
       n[1] = transformSymAux(c, a)
     return n
-  of nkLambdaKinds, nkProcDef, nkFuncDef, nkMethodDef, nkConverterDef: # todo optimize nosideeffects?
+  of nkProcDef: # todo optimize nosideeffects?
     result = newTransNode(n)
-    let oldProc = n[namePos].sym
-    let x = freshOwnedSym(c, oldProc, oldProc.owner)
-    c.transCon.mapping[oldProc.itemId] = x
-    introduceNewRoutineHeaderSyms(c, n[paramsPos], oldProc, x.sym)
-    if resultPos < n.len and n[resultPos] != nil:
-      introduceNewRoutineHeaderSyms(c, n[resultPos], oldProc, x.sym)
-    copyRoutineTypeHeader(c, oldProc, x.sym)
+    let x = newSymNode(copySym(n[namePos].sym, c.idgen))
+    c.transCon.mapping[n[namePos].sym.itemId] = x
     result[namePos] = x # we have to copy proc definitions for iters
     for i in 1..<n.len:
       result[i] = introduceNewLocalVars(c, n[i])
-    if x.sym.typ != nil and x.sym.typ.kind == tyProc:
-      result[paramsPos] = x.sym.typ.n
     result[namePos].sym.ast = result
   else:
     result = newTransNode(n)
@@ -572,7 +518,8 @@ proc transformAddrDeref(c: PTransf, n: PNode, kinds: TNodeKinds, isAddr = false)
           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)
+          not (isAddr and n.typ.kind == tyVar and n[0][0].typ.kind == tyRef and
+              n[0][0].kind == nkObjConstr)
         : # elimination is harmful to `for tuple unpack` because of newTupleAccess
           # it is also harmful to openArrayLoc (var openArray) for strings
       # addr ( deref ( x )) --> x
@@ -605,34 +552,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,
@@ -721,7 +641,7 @@ type
     paDirectMapping, paFastAsgn, paFastAsgnTakeTypeFromArg
     paVarAsgn, paComplexOpenarray, paViaIndirection
 
-proc putArgInto(arg: PNode, formal: PType; borrowedFirstArg = false): TPutArgInto =
+proc putArgInto(arg: PNode, formal: PType): TPutArgInto =
   # This analyses how to treat the mapping "formal <-> arg" in an
   # inline context.
   if formal.kind == tyTypeDesc: return paDirectMapping
@@ -748,11 +668,6 @@ proc putArgInto(arg: PNode, formal: PType; borrowedFirstArg = false): TPutArgInt
   of nkAddr, nkHiddenAddr:
     result = putArgInto(arg[0], formal)
     if result == paViaIndirection: result = paFastAsgn
-  of nkHiddenStdConv, nkHiddenSubConv, nkConv:
-    if compareTypes(arg.typ, arg[1].typ, dcEqIgnoreDistinct, {IgnoreRangeShallow}):
-      result = putArgInto(arg[1], formal)
-    else:
-      result = paFastAsgn
   of nkCurly, nkBracket:
     for i in 0..<arg.len:
       if putArgInto(arg[i], formal) != paDirectMapping:
@@ -772,13 +687,6 @@ proc putArgInto(arg: PNode, formal: PType; borrowedFirstArg = false): TPutArgInt
     if skipTypes(formal, abstractInst).kind in {tyVar, tyLent}: result = paVarAsgn
     else: result = paFastAsgn
 
-  if borrowedFirstArg and result == paDirectMapping and parampatterns.exprRoot(arg) == nil and
-           parampatterns.isAssignable(nil, arg) == arNone:
-    # Inline iterators like `items(array)` borrow from the first argument.
-    # If that argument is just a transient expression, materialize it so the
-    # lifted closure keeps the backing storage alive across yields.
-    result = paFastAsgnTakeTypeFromArg
-
 proc findWrongOwners(c: PTransf, n: PNode) =
   if n.kind == nkVarSection:
     let x = n[0][0]
@@ -851,9 +759,7 @@ proc transformFor(c: PTransf, n: PNode): PNode =
 
   discard c.breakSyms.pop
 
-  var iter = call[0].sym
-  if sfBorrow in iter.flags and iter.kind in routineKinds:
-    iter = resolveBorrowedRoutineSym(c, iter, n.info)
+  let iter = call[0].sym
 
   var v = newNodeI(nkVarSection, n.info)
   for i in 0..<n.len - 2:
@@ -876,16 +782,13 @@ proc transformFor(c: PTransf, n: PNode): PNode =
   if iter.kind != skIterator: return result
   # generate access statements for the parameters (unless they are constant)
   pushTransCon(c, newC)
-  let borrowedIterResult =
-    iter.typ != nil and iter.typ.returnType != nil and
-    skipTypes(iter.typ.returnType, abstractInst).kind in {tyLent, tyVar}
   for i in 1..<call.len:
     var arg = transform(c, call[i])
     let ff = skipTypes(iter.typ, abstractInst)
     # can happen for 'nim check':
     if i >= ff.n.len: return result
     var formal = ff.n[i].sym
-    let pa = putArgInto(arg, formal.typ, borrowedIterResult and i == 1)
+    let pa = putArgInto(arg, formal.typ)
     case pa
     of paDirectMapping:
       newC.mapping[formal.itemId] = arg
@@ -897,25 +800,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
@@ -1067,23 +957,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]
@@ -1112,9 +985,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)
 

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
@@ -225,17 +225,6 @@ proc getRoot*(n: PNode): PSym =
     else: result = nil
   else: result = nil
 
-proc isCursor*(n: PNode): bool =
-  case n.kind
-  of nkSym:
-    sfCursor in n.sym.flags
-  of nkDotExpr:
-    isCursor(n[1])
-  of nkCheckedFieldExpr:
-    isCursor(n[0])
-  else:
-    false
-
 proc stupidStmtListExpr*(n: PNode): bool =
   for i in 0..<n.len-1:
     if n[i].kind notin {nkEmpty, nkCommentStmt}: return false

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:
@@ -99,13 +98,12 @@ proc typeAllowedAux(marker: var IntSet, typ: PType, kind: TSymKind,
       if isInlineIterator(typ) and kind in {skVar, skLet, skConst, skParam, skResult}:
         # only closure iterators may be assigned to anything.
         result = t
-      let innerFlags = flags - {taObjField, taTupField, taIsOpenArray}
-      let f = if kind in {skProc, skFunc}: innerFlags+{taNoUntyped} else: innerFlags
+      let f = if kind in {skProc, skFunc}: flags+{taNoUntyped} else: flags
       for _, a in t.paramTypes:
         if result != nil: break
-        result = typeAllowedAux(marker, a, skParam, c, f)
+        result = typeAllowedAux(marker, a, skParam, c, f-{taIsOpenArray})
       if result.isNil and t.returnType != nil:
-        result = typeAllowedAux(marker, t.returnType, skResult, c, innerFlags)
+        result = typeAllowedAux(marker, t.returnType, skResult, c, flags)
   of tyTypeDesc:
     if kind in {skVar, skLet, skConst} and taProcContextIsNotMacro in flags:
       result = t
@@ -189,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

compiler/types.nim

@@ -165,7 +165,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 +766,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]
@@ -1246,7 +1246,7 @@ proc sameTypeAux(x, y: PType, c: var TSameTypeClosure): bool =
     c.flags = oldFlags
 
   if x == y: return true
-  let aliasSkipSet = maybeSkipRange({tyAlias, tyInferred})
+  let aliasSkipSet = maybeSkipRange({tyAlias})
   var a = skipTypes(x, aliasSkipSet)
   while a.kind == tyUserTypeClass and tfResolved in a.flags:
     a = skipTypes(a.last, aliasSkipSet)
@@ -1418,10 +1418,9 @@ proc sameBackendTypeIgnoreRange*(x, y: PType): bool =
   c.cmp = dcEqIgnoreDistinct
   result = sameTypeAux(x, y, c)
 
-proc sameBackendTypePickyAliases*(x, y: PType, flags: TTypeCmpFlags = {}): bool =
+proc sameBackendTypePickyAliases*(x, y: PType): bool =
   var c = initSameTypeClosure()
-  c.flags.incl {IgnoreTupleFields, IgnoreRangeShallow, PickyCAliases, PickyBackendAliases}
-  c.flags.incl flags
+  c.flags.incl {IgnoreTupleFields, PickyCAliases, PickyBackendAliases}
   c.cmp = dcEqIgnoreDistinct
   result = sameTypeAux(x, y, c)
 
@@ -1486,17 +1485,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 =
@@ -1516,31 +1506,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:
@@ -1551,8 +1516,6 @@ proc containsGenericTypeIter(t: PType, closure: RootRef): bool =
     return false
   of GenericTypes + tyTypeClasses + {tyFromExpr}:
     return true
-  of tyGenericInst:
-    return t.isConcept
   else:
     return false
 
@@ -1898,7 +1861,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):
@@ -1909,30 +1872,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
@@ -2092,7 +2044,6 @@ proc genericRoot*(t: PType): PType =
 
 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
@@ -2117,7 +2068,7 @@ proc reduceToBase*(f: PType): PType =
     result = reduceToBase(f.typeBodyImpl)
   of tyUserTypeClass:
     if f.isResolvedUserTypeClass:
-      result = f.base
+      result = f.base  # ?? idk if this is right
     else:
       result = f.skipModifier
   of tyStatic, tyOwned, tyVar, tyLent, tySink:
@@ -2129,7 +2080,3 @@ proc reduceToBase*(f: PType): PType =
     result = f.elementType
   else:
     result = f
-
-proc supportsCopyMem*(t: PType): bool =
-  let t = t.skipTypes({tyVar, tyLent, tyGenericInst, tyAlias, tySink, tyInferred})
-  result = not containsGarbageCollectedRef(t) and not hasDestructor(t)

compiler/varpartitions.nim

@@ -185,9 +185,6 @@ proc root(v: var Partitions; start: int): int =
 proc potentialMutation(v: var Partitions; s: PSym; level: int; info: TLineInfo) =
   let id = variableId(v, s)
   if id >= 0:
-    # mutated here => alive here: keep aliveEnd in sync so dangerousMutation catches
-    # mutations recorded after the var's last use (e.g. via a call arg). See #25595.
-    v.s[id].aliveEnd = max(v.s[id].aliveEnd, v.abstractTime)
     let r = root(v, id)
     let flags = if s.kind == skParam:
                   if isConstParam(s):
@@ -677,13 +674,9 @@ proc deps(c: var Partitions; dest, src: PNode) =
           else:
             let srcid = variableId(c, s)
             if srcid >= 0:
-              if s.kind notin {skResult, skParam} and
-                  c.s[srcid].aliveEnd < c.s[vid].aliveEnd and
-                  c.g.config.backend != backendJs:
-                # you cannot borrow from a local that lives shorter than 'vid'.
-                # On a traced (JS/GC) target the source object stays alive as long
-                # as the alias references it, so this lifetime rule does not apply;
-                # value-semantics safety is enforced by `dangerousMutation` instead.
+              if s.kind notin {skResult, skParam} and (
+                  c.s[srcid].aliveEnd < c.s[vid].aliveEnd):
+                # you cannot borrow from a local that lives shorter than 'vid':
                 when explainCursors: echo "B not a cursor ", d.sym, " ", c.s[srcid].aliveEnd, " ", c.s[vid].aliveEnd
                 c.s[vid].flags.incl preventCursor
               elif {isReassigned, preventCursor} * c.s[srcid].flags != {}:
@@ -1007,25 +1000,16 @@ proc checkBorrowedLocations*(par: var Partitions; body: PNode; config: ConfigRef
       #if par.s[rid].con.kind == isRootOf and dangerousMutation(par.graphs[par.s[rid].con.graphIndex], par.s[i]):
       #  cannotBorrow(config, s, par.graphs[par.s[rid].con.graphIndex])
 
-proc jsDeepCopied(t: PType): bool =
-  ## On the JS backend `nimCopy` deep-copies these type classes on every
-  ## assignment, so eliding the copy for a safe alias is worthwhile even when
-  ## the type has no C-style destructor.
-  t.skipTypes({tyGenericInst, tyAlias, tyDistinct, tyVar, tyLent}).kind in
-    {tyObject, tyTuple, tyArray, tySequence, tyString}
-
 proc computeCursors*(s: PSym; n: PNode; g: ModuleGraph) =
-  let jsCursors = g.config.backend == backendJs
   var par = computeGraphPartitions(s, n, g, {cursorInference})
   for i in 0 ..< par.s.len:
     let v = addr(par.s[i])
     if v.flags * {ownsData, preventCursor, isConditionallyReassigned} == {} and
         v.sym.kind notin {skParam, skResult} and
-        v.sym.flags * {sfThread, sfGlobal} == {} and
-        (hasDestructor(v.sym.typ) or (jsCursors and jsDeepCopied(v.sym.typ))) and
+        v.sym.flags * {sfThread, sfGlobal} == {} and hasDestructor(v.sym.typ) and
         v.sym.typ.skipTypes({tyGenericInst, tyAlias}).kind != tyOwned and
-        not hasDisabledAsgn(g, v.sym.typ) and
-        not hasDisabledDup(g, v.sym.typ):
+        (getAttachedOp(g, v.sym.typ, attachedAsgn) == nil or
+        sfError notin getAttachedOp(g, v.sym.typ, attachedAsgn).flags):
       let rid = root(par, i)
       if par.s[rid].con.kind == isRootOf and dangerousMutation(par.graphs[par.s[rid].con.graphIndex], par.s[i]):
         discard "cannot cursor into a graph that is mutated"

compiler/vm.nim

@@ -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.} =
@@ -663,10 +663,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 +859,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,23 +1435,15 @@ 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:
@@ -1470,7 +1459,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
         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 +1472,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 +1714,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 +1873,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 +1882,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 +2051,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 +2063,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
@@ -2360,7 +2333,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 +2343,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,
@@ -2558,7 +2532,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 +2560,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

@@ -105,7 +105,7 @@ type
     opcIsNil, opcOf, opcIs,
     opcParseFloat, opcConv, opcCast,
     opcQuit, opcInvalidField,
-    opcNarrowS, opcNarrowU, opcNarrowR
+    opcNarrowS, opcNarrowU,
     opcSignExtend,
 
     opcAddStrCh,
@@ -243,18 +243,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
@@ -276,7 +270,7 @@ 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
 
@@ -298,17 +292,13 @@ 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), templInstCounter: new int)
+    cache: cache, config: g.config, graph: g, idgen: idgen)
 
 proc refresh*(c: PCtx, module: PSym; idgen: IdGenerator) =
   c.module = module