jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix #959

Browse source 
Variable declarations using a type class will be subject to type inference similar to the one
already present in type coercions and the return type inference.
This commit is contained in:
Zahary Karadjov 2014-09-04 23:50:00 +03:00
commit 9a3963f51b
3 changed files with 27 additions and 6 deletions
Download patch file Download diff file Expand all files Collapse all files

9
compiler/semstmts.nim
View file

@ -350,9 +350,14 @@ proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode =
var def: PNode var def: PNode
if a.sons[length-1].kind != nkEmpty: if a.sons[length-1].kind != nkEmpty:
def = semExprWithType(c, a.sons[length-1], {efAllowDestructor}) def = semExprWithType(c, a.sons[length-1], {efAllowDestructor})
if typ != nil:
if typ.isMetaType:
def = inferWithMetaType(c, typ, def)
typ = def.typ
else:
# BUGFIX: ``fitNode`` is needed here! # BUGFIX: ``fitNode`` is needed here!
# check type compability between def.typ and typ: # check type compability between def.typ and typ
if typ != nil: def = fitNode(c, typ, def) def = fitNode(c, typ, def)
else: else:
typ = skipIntLit(def.typ) typ = skipIntLit(def.typ)
if typ.kind in {tySequence, tyArray, tySet} and if typ.kind in {tySequence, tyArray, tySet} and

11
doc/manual.txt
View file

@ -3671,8 +3671,8 @@ once for each tested type and any static code included within them will also be
executed once. executed once.
Return Type Inference Type inference with type classes
--------------------- --------------------------------
If a type class is used as the return type of a proc and it won't be bound to If a type class is used as the return type of a proc and it won't be bound to
a concrete type by some of the proc params, Nim will infer the return type a concrete type by some of the proc params, Nim will infer the return type
@ -3681,13 +3681,18 @@ from the proc body. This is usually used with the ``auto`` type class:
.. code-block:: nim .. code-block:: nim
proc makePair(a, b): auto = (first: a, second: b) proc makePair(a, b): auto = (first: a, second: b)
The return type will be treated as additional generic param and can be The return type will be treated as an additional generic param and can be
explicitly specified at call sites as any other generic param. explicitly specified at call sites as any other generic param.
Future versions of Nim may also support overloading based on the return type Future versions of Nim may also support overloading based on the return type
of the overloads. In such settings, the expected result type at call sites may of the overloads. In such settings, the expected result type at call sites may
also influence the inferred return type. also influence the inferred return type.
Likewise, if a type class is used in another position where Nim expects a
concrete type (e.g. a variable declaration or a type coercion), Nim will try to
infer the concrete type by applying the sane matching algorithm also used in
overload resolution.
Symbol lookup in generics Symbol lookup in generics
------------------------- -------------------------

11
tests/metatype/typeclassinference.nim
View file

@ -1,3 +1,8 @@
discard """
errormsg: "type mismatch: got (string) but expected 'ptr'"
line: 20
"""
import typetraits import typetraits
type type
@ -8,3 +13,9 @@ var x = Vec([1, 2, 3])
static: static:
assert x.type.name == "Vec[static[int](3), int]" assert x.type.name == "Vec[static[int](3), int]"
var str1: string = "hello, world!"
var ptr1: ptr = addr(str1)
var str2: string = "hello, world!"
var ptr2: ptr = str2