changed type() to typeof() in docs and error messages (#14084)

compiler/semcall.nim

@@ -633,7 +633,7 @@ proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym): PNode =
     if s.ast[genericParamsPos].safeLen != n.len-1:
       let expected = s.ast[genericParamsPos].safeLen
       localError(c.config, getCallLineInfo(n), errGenerated, "cannot instantiate: '" & renderTree(n) &
-         "'; got " & $(n.len-1) & " type(s) but expected " & $expected)
+         "'; got " & $(n.len-1) & " typeof(s) but expected " & $expected)
       return n
     result = explicitGenericSym(c, n, s)
     if result == nil: result = explicitGenericInstError(c, n)

compiler/types.nim

@@ -587,7 +587,7 @@ proc typeToString(typ: PType, prefer: TPreferedDesc = preferName): string =
       if t.n == nil:
         result = "unknown"
       else:
-        result = "type(" & renderTree(t.n) & ")"
+        result = "typeof(" & renderTree(t.n) & ")"
     of tyArray:
       if t[0].kind == tyRange:
         result = "array[" & rangeToStr(t[0].n) & ", " &

doc/destructors.rst

@@ -48,7 +48,7 @@ written as:
     a.len = b.len
     a.cap = b.cap
     if b.data != nil:
-      a.data = cast[type(a.data)](alloc(a.cap * sizeof(T)))
+      a.data = cast[typeof(a.data)](alloc(a.cap * sizeof(T)))
       for i in 0..<a.len:
         a.data[i] = b.data[i]
 
@@ -76,7 +76,7 @@ written as:
   proc createSeq*[T](elems: varargs[T]): myseq[T] =
     result.cap = elems.len
     result.len = elems.len
-    result.data = cast[type(result.data)](alloc(result.cap * sizeof(T)))
+    result.data = cast[typeof(result.data)](alloc(result.cap * sizeof(T)))
     for i in 0..<result.len: result.data[i] = elems[i]
 
   proc len*[T](x: myseq[T]): int {.inline.} = x.len

doc/manual.rst

@@ -2354,7 +2354,7 @@ The convertible relation can be relaxed by a user-defined type
   echo x # => 97
 
 The type conversion ``T(a)`` is an L-value if ``a`` is an L-value and
-``typeEqualsOrDistinct(T, type(a))`` holds.
+``typeEqualsOrDistinct(T, typeof(a))`` holds.
 
 
 Assignment compatibility

doc/manual_experimental.rst

@@ -619,7 +619,7 @@ type is an instance of it:
 
   type
     Functor[A] = concept f
-      type MatchedGenericType = genericHead(f.type)
+      type MatchedGenericType = genericHead(typeof(f))
         # `f` will be a value of a type such as `Option[T]`
         # `MatchedGenericType` will become the `Option` type
 
@@ -652,7 +652,7 @@ matched to a concrete type:
 
       t1 < t2 is bool
 
-      type TimeSpan = type(t1 - t2)
+      type TimeSpan = typeof(t1 - t2)
       TimeSpan * int is TimeSpan
       TimeSpan + TimeSpan is TimeSpan
 

doc/tut2.rst

@@ -651,7 +651,7 @@ Example: Lifting Procs
     ##  # now abs(@[@[1,-2], @[-2,-3]]) == @[@[1,2], @[2,3]]
     proc fname[T](x: openarray[T]): auto =
       var temp: T
-      type outType = type(fname(temp))
+      type outType = typeof(fname(temp))
       result = newSeq[outType](x.len)
       for i in 0..<x.len:
         result[i] = fname(x[i])

lib/js/jsffi.nim

@@ -83,7 +83,7 @@ proc toJsKey*[T: SomeFloat](text: cstring, t: type T): T {.importcpp: "parseFloa
 
 type
   JsKey* = concept a, type T
-    cstring.toJsKey(T) is type(a)
+    cstring.toJsKey(T) is T
 
   JsObject* = ref object of JsRoot
     ## Dynamically typed wrapper around a JavaScript object.

lib/pure/typetraits.nim

@@ -48,7 +48,7 @@ proc genericHead*(t: typedesc): typedesc {.magic: "TypeTrait".}
   ## .. code-block:: nim
   ##   type
   ##     Functor[A] = concept f
-  ##       type MatchedGenericType = genericHead(f.type)
+  ##       type MatchedGenericType = genericHead(typeof(f))
   ##         # `f` will be a value of a type such as `Option[T]`
   ##         # `MatchedGenericType` will become the `Option` type
 

lib/system/dollars.nim

@@ -45,9 +45,9 @@ proc `$`*(t: typedesc): string {.magic: "TypeTrait".}
   ## `typetraits module <typetraits.html>`_.
   ##
   ## .. code-block:: Nim
-  ##   doAssert $(type(42)) == "int"
+  ##   doAssert $(typeof(42)) == "int"
-  ##   doAssert $(type("Foo")) == "string"
+  ##   doAssert $(typeof("Foo")) == "string"
-  ##   static: doAssert $(type(@['A', 'B'])) == "seq[char]"
+  ##   static: doAssert $(typeof(@['A', 'B'])) == "seq[char]"
 
 when defined(nimHasIsNamedTuple):
   proc isNamedTuple(T: typedesc): bool {.magic: "TypeTrait".}