Forem: ringabout

closes #21536; fixes manual.

https://forum.nim-lang.org/t/9989 (3/12)

https://forum.nim-lang.org/t/10024 (3/19)

https://forum.nim-lang.org/t/10040 (3/26)

Participating in contributions

Following The Roadmap 2023 for community building , you could join us in the matrix space where we discuss how to build a community. We appreciate doable suggestions and helps, such as improving the workflow, implementing the roadmap, suggesting doable tasks, reviewing code from contributors. United we stand. We shall work together to make the community thrive.

Sponsorship

Many thanks to Yepoleb, lenis0012, pietroppeter, Clonkk, mode80, Phil, CxPlanner, shirleyquirk, elcritch, geotre, thinkwelltwd, xrfez, enthus1ast, piertoni, Dnanilem, gemath for sponsoring me on GitHub.

Contribute to the Python-like Nim language

ringabout — Mon, 27 Mar 2023 15:43:30 +0000

Progress

fixes the documentation of typeclasses

The parser has been changed, now you need to use type RecordType = (tuple or object) ro declare types classes starting with tuple or object instead of type RecordType = tuple or object.

forbids using `system.any` for type conversions

fixes #14255; Crash in compiler when using system.any by accident.

var a = newSeq[bool](1000)
if any(a):
  echo "ok?"

Now it gives proper an error message => "Error: illegal type conversion to 'any'".

fixes templates with untyped parameters resolve private fields wrongly in generics

fixes #3770; templates with untyped parameters resolve private fields wrongly in generics.

type
  Noice* = object
    hidden: int

template jjj*: Noice =
  Noice(hidden: 15)

# bug #3770
import m3770

doAssert $jjj() == "(hidden: 15)"  # works

proc someGeneric(_: type) =
  doAssert $jjj() == "(hidden: 15)"

someGeneric(int)

Now the example compiles.

(WIP) adds compiler support for object construction shorthand

WIP adds compiler support for object construction shorthand.

type
  Vector = object
    a: int = 999
    b, c: int

block: # positional construction
  ## It specifies all the unnamed fields
  var x = Vector(1, 2, 3)
  doAssert x.b == 2

block:
  ## unnamed fields can be mixed with named fields
  block:
    var x = Vector(a: 1, 2, 3)
    doAssert x.c == 3

  block:
    var x = Vector(1, b: 2, 3)
    doAssert x.c == 3

  block:
    var x = Vector(1, 2, c: 3)
    doAssert x.c == 3

block:
  ## Object variants support unnamed fields for tags, which should be known at the compile time.
  type
    Color = enum
      Red, Blue, Yellow
    Factor = object
      id: int
      case flag: Color
      of Red:
        num: int
      of Blue, Yellow:
        done: bool
      name: string

  block:
    var x = Factor(1, Red, 2, "1314")
    doAssert x.num == 2

  block:
    var x = Factor(1, Blue, true, "1314")
    doAssert x.done == true

  block:
    var x = Factor(1, Yellow, false, "1314")
    doAssert x.done == false


  type
    Ciao = object
      id: int
      case flag: bool = false
      of true:
        num: int
      of false:
        done: bool
      name: string

  block:
    var x = Ciao(12, false, false, "123")
    doAssert x.done == false

  block:
    var x = Ciao(12, flag: true, 1, "123")
    doAssert x.num == 1

Weekly collection

fixes #19857; Exception raised in closure may be "skipped" in ORC.

https://forum.nim-lang.org/t/9989 (3/12)

https://forum.nim-lang.org/t/10024 (3/19)

Participating in contributions

Sponsorship

My Nim Development Weekly Report (3/19)

ringabout — Mon, 20 Mar 2023 04:21:06 +0000

Progress

Checks the potential errors with closure calls

Adds a prepass for codeReordering

add a prepass for codeReordering.

To keep backwards compatibility. It adds a prepass for codeReordering. Before processing all the source code, it iterates all the nodes and looks for {.experimental: "codeReordering"}. If the flag is found, it will enter the processing in the codeReordering mode.

Forbids changing branch of an object variant in ORC

fix #18977; disallow change branch of an object variant in ORC.

type
  E = enum
    a, b, c, d
  X = object
    v: int
  O = object
    case kind: E
    of a:
      a: int
    of {b, c}:
      b: float
    else:
      d: X

proc `=destroy`(x: var X) =
  echo "x destroyed"

var o = O(kind: d, d: X(v: 12345))
doAssert o.d.v == 12345

doAssertRaises(FieldDefect):
  o.kind = a

You cannot change the branch of o anymore unless you assign to it the same kind or use {.cast(uncheckedAssign).} to permit the operation.

o.kind = d
{.cast(uncheckedAssign).}:
  o.kind = a

Weekly collection

fixes #21023; Segfault when mixing seqs, orc, variants and futures.

https://forum.nim-lang.org/t/9989 (3/12)

Participating in contributions

Sponsorship

Many thanks to @Yepoleb, @lenis0012, @pietroppeter, @Clonkk, @mode80, @phil, @CxPlanner, @shirleyquirk, @elcritch, @geotre, @thinkwelltwd, @xrfez, @enthus1ast, @piertoni, @Dnanilem for sponsoring me on GitHub.

My Nim Development Weekly Report (3/12)

ringabout — Mon, 13 Mar 2023 03:28:03 +0000

Progress

  proc b[T](v: T): seq[int] =
    let x = 0
    @[]

  doAssert b(0) == @[]

The type of @[] is incomplete, which is of seq[empty] type. By means of the return type of the generics, we could infer its type. Using top down type inference, we pass the expected type, namely seq[int], to the return expression. Finally, the return type is passed to the magic mArrToSeq, where we replace the incomplete type with seq[int].

Initialize all the missing fields when discriminator is assigned

type
  Result = object
    case o: bool
    of false:
      e: int
    of true:
      v: float

var x = Result(o: true) is now equal to var x = Result(o: true, v: 0.0). The v field is initialized to 0.0 so that it won't cause problems for ARC/ORC.

don't transform yields in the var section when introducing new local vars

fixes #21306; fixes #20485; don't transform yields in the var section when introducing new local vars.

fixes ambiguous calls compiles when module name are equal

fixes #21496; fixes ambiguous calls compiles when module name are equal.

- a
   - def.nim
- b
   - def.nim
- project.nimble

The a/def and b/def shares the same owner, namely project which is the name of the nimble file. We cannot distinguish them by their owners.

if sym.kind == skModule and conflict.kind == skModule and sym.owner == conflict.owner:

Instead, we need to use sym.position which stands for an unique index corresponding to the module's fileIdx for symbols with a skModule kind.

if sym.kind == skModule and conflict.kind == skModule and sym.position == conflict.position:

Weekly collection

remove nosinks hacks from compiler.

Participating in contributions

Sponsorship

Many thanks to Yepoleb, lenis0012, pietroppeter, Clonkk, mode80, Phil, CxPlanner, shirleyquirk, elcritch, geotre, thinkwelltwd, xrfez, enthus1ast, piertoni, Dnanilem for sponsoring me on GitHub.

My Nim Development Weekly Report (3/5)

ringabout — Mon, 06 Mar 2023 02:54:38 +0000

Progress

chores

test DLL generation with ORC.

fixes sinkinference documentation, which has been disabled.

implements wasMoved hook

fixes #19291; implements wasMoved hook.

You can now register a wasMoved hook.

type
  Game = object

proc `=wasMoved`(x: var Game) {.error.}

hash types based on custom paths

fixes #20139; hash types based on custom paths.

Now the object type with the same name in the same file name but resides in different directories won't conflict with each other anymore. The PR takes the path of the type into consideration, which prevents conflicts.

fixes top level variables inside loops are not reset in VM

fixes #10938; fixes #13312; fixes #13918; fixes #20985; always initializes global variables with null values in VM.

static:
  for i in '1' .. '2':
    var s: set[char]
    doAssert s == {}
    incl(s, i)

The variable s wasn't initialized properly in the loop. It caused s to keep the old value after the first iteration. My solution is to initialize s each time the var section is executed, which is reset for every iteration.

fixes type erasures for quoted variables

fixes #21326; fixes #7375; fixes #11986; fixes #9607; rework quote do; getAst uses type info to annotate the type of quoted variables; no more type erasures for quoted variables.

import macros

macro foo(body: untyped): untyped =
  let a = body.lineInfoObj()
  result = quote do:
    echo `a`

foo:
  let c = 1

The VM is an untyped executor, which erases types of expressions after execution. In this case, a is evaluated in the VM, which loses its type, namely LineInfo after evaluation. So we should collect the type information and annotate the type of a when expanding quote do. I store the type information in the parameters of the dummy templates used by quote do, which is used to restore the type of quoted variables.

replaces implicit passes array registered at runtime with explicit function calls; simplify compilation pipeline

replaces implicit passes array registered at runtime with explicit function calls; simplify compilation pipeline.

proc processPipeline(graph: ModuleGraph; semNode: PNode; bModule: PPassContext): PNode =
  case graph.pipelinePass
  of CgenPass:
    result = semNode
    if bModule != nil:
      genTopLevelStmt(BModule(bModule), result)
  of JSgenPass:
    when not defined(leanCompiler):
      result = processJSCodeGen(bModule, semNode)
  of GenDependPass:
    result = addDotDependency(bModule, semNode)
  of SemPass:
    result = graph.emptyNode
  of Docgen2Pass, Docgen2TexPass:
    when not defined(leanCompiler):
      result = processNode(bModule, semNode)
  of Docgen2JsonPass:
    when not defined(leanCompiler):
      result = processNodeJson(bModule, semNode)
  of EvalPass, InterpreterPass:
    result = interpreterCode(bModule, semNode)
  of NonePass:
    doAssert false, "use setPipeLinePass to set a proper PipelinePass"

The processPipeline explicitly calls the code generator, which makes the code more clear. It is the second step towards to remove forward declaration.

Weekly collection

fixes the linkerexe of riscv64 in config.

Participating in contributions

I have created a matrix space for contributions to the official Nim projects. If you are already a contributor of the official Nim projects, welcome to this space to discuss contributions. If you are willing to take up some quests for fun, I have prepared a list for you, which contains a few contribution-friendly issues.

Sponsorship

Many thanks to @Yepoleb, @lenis0012, @pietroppeter, @Clonkk, @mode80, @phil, @CxPlanner, @shirleyquirk, @elcritch, @geotre, @thinkwelltwd, @xrfez, @enthus1ast for sponsoring me on GitHub.

My Nim Development Weekly Report (2/26)

ringabout — Fri, 03 Mar 2023 10:17:41 +0000

Progress

chores

invalid module names errors have been improved, it now says that a module name must be a valid Nim identifier.

csources_v2 can build the ORC-booted compiler; building now uses strict mode.

saves one unnecessary compare which is also a small regression.

closes #17864; add a test case.

use {.push warning[BareExcept]:off.} to override settings temporarily.

Nim now parses the whole module at one time

fixes #19795; fixes #11852; fixes #19974; remove parsing pipeline, Nim now parses the whole module at one time

destructor analysis

Now the destructor analysis can analyze the whole module at one time, which means the declarations won't affect the analysis of global variables.

type Vector = seq[int]

var vect: Vector = newSeq[int](5)
doAssert vect == @[0, 0, 0, 0, 0]

let vectCopy = vect
proc p(): int = 3

doAssert vect == @[0, 0, 0, 0, 0]

You don't need to put the global statements to a function anymore. It can be run with ARC/ORC as it is.

push pragmas

push pragmas now work within functions.

proc foo(x: string, y: int, res: int) =
  {.push checks: off}
  var a: ptr char = unsafeAddr(x[y])
  {.pop.}
  if x.len > y:
    doAssert ord(a[]) == 51
  else:
    doAssert x.len + 48 == res

foo("", 0, 48)
foo("abc", 40, 51)

fixes object with distinct defaults or `initTable` defaults

fixes #20695; fixes object with distinct defaults and tables.

import std/[tables, times]

block:
  block:
    type
      Default = object
        tabs: Table[string, int] = initTable[string, int]()

    let d = default(Default)
    doAssert d.tabs.len == 0

  block:
    type DjangoDateTime = distinct DateTime

    type Default = object
      data: DjangoDateTime = DjangoDateTime(DateTime())

    let x = default(Default)
    doAssert x.data is DjangoDateTime

All of them now works.

Work in progress

Overrides =copy for PackedSets.

abolish using passes in the compiler; simplify compilation pipeline.

fixes #21326; fixes #7375; fixes #11986; fixes #9607; getAst uses type info to annotate the type of quoted variables; no more type erasures for quoted variables.

Weekly collection