Merge branch 'devel' into pr_holey_enum

…lude configuration options

changelog.md

@@ -3,6 +3,8 @@
 
 ## Changes affecting backward compatibility
 
+- `-d:nimPreviewHashRef` becomes the default. `hashes.hash` can now support `object` and `ref` (can be overloaded in user code).
+
 - `-d:nimPreviewFloatRoundtrip` becomes the default. `system.addFloat` and `system.$` now can produce string representations of
 floating point numbers that are minimal in size and possess round-trip and correct
 rounding guarantees (via the
@@ -17,7 +19,7 @@ rounding guarantees (via the
 - Unknown warnings and hints now gives warnings `warnUnknownNotes` instead of
 errors.
 
-- backticked symbols are type checked in the `asm/emit` statements. Use `--legacy:noAsmSemSymbol` for a transitional period.
+- 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.
 

compiler/ccgtypes.nim

@@ -247,6 +247,7 @@ proc isOrHasImportedCppType(typ: PType): bool =
   searchTypeFor(typ.skipTypes({tyRef}), isImportedCppType)
 
 proc hasNoInit(t: PType): bool =
+  let t = skipTypes(t, {tyGenericInst})
   result = t.sym != nil and sfNoInit in t.sym.flags
 
 proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDescKind): Rope

compiler/commands.nim

@@ -884,11 +884,19 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
   of "import":
     expectArg(conf, switch, arg, pass, info)
     if pass in {passCmd2, passPP}:
-      conf.implicitImports.add findModule(conf, arg, toFullPath(conf, info)).string
+      let m = findModule(conf, arg, toFullPath(conf, info)).string
+      if m.len == 0:
+        localError(conf, info, "Cannot resolve filename: " & arg)
+      else:
+        conf.implicitImports.add m
   of "include":
     expectArg(conf, switch, arg, pass, info)
     if pass in {passCmd2, passPP}:
-      conf.implicitIncludes.add findModule(conf, arg, toFullPath(conf, info)).string
+      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
   of "listcmd":
     processOnOffSwitchG(conf, {optListCmd}, arg, pass, info)
   of "asm":

compiler/condsyms.nim

@@ -172,7 +172,6 @@ proc initDefines*(symbols: StringTableRef) =
   defineSymbol("nimHasDefaultFloatRoundtrip")
   defineSymbol("nimHasXorSet")
 
-  defineSymbol("nimHasAsmSemSymbol")
   defineSymbol("nimHasSetLengthSeqUninitMagic")
   defineSymbol("nimHasPreviewDuplicateModuleError")
 

compiler/options.nim

@@ -250,8 +250,6 @@ type
       ## Useful for libraries that rely on local passC
     jsNoLambdaLifting
       ## Old transformation for closures in JS backend
-    noAsmSemSymbol
-      ## disable type checking for backticked symbols in the `asm/emit` statements
     noPanicOnExcept
       ## don't panic on bare except
 

compiler/pragmas.nim

@@ -637,11 +637,10 @@ proc semAsmOrEmit*(con: PContext, n: PNode, marker: char): PNode =
         # XXX what to do here if 'amb' is true?
         if e != nil:
           incl(e.flags, sfUsed)
-
-          if noAsmSemSymbol in con.config.legacyFeatures:
-            result.add newSymNode(e)
-          else:
+          if isDefined(con.config, "nimPreviewAsmSemSymbol"):
             result.add con.semExprWithType(con, newSymNode(e), {efTypeAllowed})
+          else:
+            result.add newSymNode(e)
         else:
           result.add newStrNode(nkStrLit, sub)
       else:

compiler/semtypes.nim

@@ -556,7 +556,7 @@ proc semTuple(c: PContext, n: PNode, prev: PType): PType =
           typ = a[^1].typ
       else:
         fitDefaultNode(c, a[^1], typ)
-        typ = a[^1].typ
+        typ = a[^1].typ.skipIntLit(c.idgen)
     elif a[^2].kind != nkEmpty:
       typ = semTypeNode(c, a[^2], nil)
       if c.graph.config.isDefined("nimPreviewRangeDefault") and typ.skipTypes(abstractInst).kind == tyRange:
@@ -928,7 +928,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
+        typ = n[^1].typ.skipIntLit(c.idgen)
         propagateToOwner(rectype, typ)
     elif n[^2].kind == nkEmpty:
       localError(c.config, n.info, errTypeExpected)

compiler/semtypinst.nim

@@ -280,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
+      result.sym.typ = result.sym.ast.typ.skipIntLit(cl.c.idgen)
     # sym type can be nil if was gensym created by macro, see #24048
     if result.sym.typ != nil and result.sym.typ.kind == tyVoid:
       # don't add the 'void' field

koch.nim

@@ -11,12 +11,12 @@
 
 const
   # examples of possible values for repos: Head, ea82b54
-  NimbleStableCommit = "9207e8b2bbdf66b5a4d1020214cff44d2d30df92" # 0.20.1
-  AtlasStableCommit = "26cecf4d0cc038d5422fc1aa737eec9c8803a82b" # 0.9
+  NimbleStableCommit = "9207e8b2bbdf66b5a4d1020214cff44d2d30df92"    # 0.20.1
+  AtlasStableCommit = "2aa62121b40d580aa2fb27920a37b938d36c5f57"     # 0.9.4
   ChecksumsStableCommit = "0b8e46379c5bc1bf73d8b3011908389c60fb9b98" # 2.0.1
   SatStableCommit = "faf1617f44d7632ee9601ebc13887644925dcc01"
 
-  NimonyStableCommit = "1dbabac403ae32e185ee4c29f006d04e04b50c6d" # unversioned \
+  NimonyStableCommit = "3660f375dc0ec25da3401d3eb28603864340dc6d" # unversioned \
     # Note that Nimony uses Nim as a git submodule but we don't want to install
     # Nimony's dependency to Nim as we are Nim. So a `git clone` without --recursive
     # is **required** here.

lib/pure/hashes.nim

@@ -51,9 +51,6 @@ runnableExamples:
     h = h !& hash(x.bar)
     result = !$h
 
-## .. important:: Use `-d:nimPreviewHashRef` to
-##    enable hashing `ref`s. It is expected that this behavior
-##    becomes the new default in upcoming versions.
 ##
 ## .. note:: If the type has a `==` operator, the following must hold:
 ##    If two values compare equal, their hashes must also be equal.
@@ -245,30 +242,25 @@ proc hash*[T](x: ptr[T]): Hash {.inline.} =
     assert cast[pointer](a[0].addr).hash == a[0].addr.hash
   hash(cast[pointer](x))
 
-when defined(nimPreviewHashRef) or defined(nimdoc):
-  proc hash*[T](x: ref[T]): Hash {.inline.} =
-    ## Efficient `hash` overload.
-    ##
-    ## .. important:: Use `-d:nimPreviewHashRef` to
-    ##    enable hashing `ref`s. It is expected that this behavior
-    ##    becomes the new default in upcoming versions.
-    runnableExamples("-d:nimPreviewHashRef"):
-      type A = ref object
-        x: int
-      let a = A(x: 3)
-      let ha = a.hash
-      assert ha != A(x: 3).hash # A(x: 3) is a different ref object from `a`.
-      a.x = 4
-      assert ha == a.hash # the hash only depends on the address
-    runnableExamples("-d:nimPreviewHashRef"):
-      # you can overload `hash` if you want to customize semantics
-      type A[T] = ref object
-        x, y: T
-      proc hash(a: A): Hash = hash(a.x)
-      assert A[int](x: 3, y: 4).hash == A[int](x: 3, y: 5).hash
-    # xxx pending bug #17733, merge as `proc hash*(pointer | ref | ptr): Hash`
-    # or `proc hash*[T: ref | ptr](x: T): Hash`
-    hash(cast[pointer](x))
+proc hash*[T](x: ref[T]): Hash {.inline.} =
+  ## Efficient `hash` overload.
+  runnableExamples:
+    type A = ref object
+      x: int
+    let a = A(x: 3)
+    let ha = a.hash
+    assert ha != A(x: 3).hash # A(x: 3) is a different ref object from `a`.
+    a.x = 4
+    assert ha == a.hash # the hash only depends on the address
+  runnableExamples:
+    # you can overload `hash` if you want to customize semantics
+    type A[T] = ref object
+      x, y: T
+    proc hash(a: A): Hash = hash(a.x)
+    assert A[int](x: 3, y: 4).hash == A[int](x: 3, y: 5).hash
+  # xxx pending bug #17733, merge as `proc hash*(pointer | ref | ptr): Hash`
+  # or `proc hash*[T: ref | ptr](x: T): Hash`
+  hash(cast[pointer](x))
 
 proc hash*(x: float): Hash {.inline.} =
   ## Efficient hashing of floats.

tests/config.nims

@@ -34,10 +34,10 @@ hint("Processing", off)
 # preview APIs are expected to be the new default in upcoming versions
 #switch("define", "nimPreviewDotLikeOps") # deprecated?
 switch("define", "nimPreviewJsonutilsHoleyEnum")
-switch("define", "nimPreviewHashRef")
 switch("define", "nimPreviewRangeDefault")
 switch("define", "nimPreviewNonVarDestructor")
 switch("define", "nimPreviewCheckedClose")
+switch("define", "nimPreviewAsmSemSymbol")
 
 switch("warningAserror", "UnnamedBreak")
 when not defined(testsConciseTypeMismatch):

tests/objects/tobject_default_value.nim

@@ -819,3 +819,18 @@ block:
 
   var t = MyTyp()
   t.thing[""] = ""
+
+
+type
+  Thing = object
+    a: int = 100 # this is fine
+    b = 100 # this is not
+
+proc overloaded[T: SomeSignedInt](x: T) = discard
+proc overloaded[T: SomeUnsignedInt](x: T) = discard
+proc overloaded[T: object](x: T) =
+  for val in fields(x):
+    var v: typeof(val)
+    overloaded(v)
+
+overloaded(Thing())