mirror of
https://github.com/nim-lang/Nim.git
synced 2025-12-29 17:34:43 +00:00
82974d91ce
Yet another one of these. Multiple changes piled up in this one. I've
only minimally cleaned it for now (debug code is still here etc). Just
want to start putting this up so I might get feedback. I know this is a
lot and you all are busy with bigger things. As per my last PR, this
might just contain changes that are not ready.
### concept instantiation uniqueness
It has already been said that concepts like `ArrayLike[int]` is not
unique for each matching type of that concept. Likewise the compiler
needs to instantiate a new proc for each unique *bound* type not each
unique invocation of `ArrayLike`
### generic parameter bindings
Couple of things here. The code in sigmatch has to give it's bindings to
the code in concepts, else the information is lost in that step. The
code that prepares the generic variables bound in concepts was also
changed slightly. Net effect is that it works better.
I did choose to use the `LayedIdTable` instead of the `seq`s in
`concepts.nim`. This was mostly to avoid confusing myself. It also
avoids some unnecessary movings around. I wouldn't doubt this is
slightly less performant, but not much in the grand scheme of things and
I would prefer to keep things as easy to understand as possible for as
long as possible because this stuff can get confusing.
### various fixes in the matching logic
Certain forms of modifiers like `var` and generic types like
`tyGenericInst` and `tyGenericInvocation` have logic adjustments based
on my testing and usage
### signature matching method adjustment
This is the weird one, like my last PR. I thought a lot about the
feedback from my last attempt and this is what I came up with. Perhaps
unfortunately I am preoccupied with a slight grey area. consider the
follwing:
```nim
type
C1 = concept
proc p[T](s: Self; x: T)
C2[T] = concept
proc p(s: Self; x: T)
```
It would be temping to say that these are the same, but I don't think
they are. `C2` makes each invocation distinct, and this has important
implications in the type system. eg `C2[int]` is not the same type as
`C2[string]` and this means that signatures are meant to accept a type
that only matches `p` for a single type per unique binding. For `C1` all
are the same and the binding `p` accepts multiple types. There are
multiple variations of this type classes, `tyAnything` and the like.
The make things more complicated, an implementation might match:
```nim
type
A = object
C3 = concept
proc p(s: Self; x: A)
```
if the implementation defines:
```nim
proc p(x: Impl; y: object)
```
while a concept that fits `C2` may be satisfied by something like:
```nim
proc p(x: Impl; y: int)
proc spring[T](x: C2[T])
```
it just depends. None of this is really a problem, it just seems to
provoke some more logic in `concepts.nim` that makes all of this (appear
to?) work. The logic checks for both kinds of matches with a couple of
caveats. The fist is that some unbind-able arrangements may be matched
during overload resolution. I don't think this is avoidable and I
actually think this is a good way to get a failed compilation. So, first
note imo is that failing during binding is preferred to forcing the
programming to write annoying stub procs and putting insane gymnastics
in the compiler. Second thing is: I think this logic is way to accepting
for some parts of overload resolutions. Particularly in `checkGeneric`
when disambiguation is happening. Things get hard to understand for me
here. ~~I made it so the implicit bindings to not count during
disambiguation~~. I still need to test this more, but the thought is
that it would help curb excessive ambiguity errors.
Again, I'm sorry for this being so many changes. It's probably
inconvenient.
---------
Co-authored-by: Andreas Rumpf <rumpf_a@web.de>
(cherry picked from commit dfab30734b)
1068 lines
42 KiB
Nim
1068 lines
42 KiB
Nim
#
|
|
#
|
|
# The Nim Compiler
|
|
# (c) Copyright 2013 Andreas Rumpf
|
|
#
|
|
# See the file "copying.txt", included in this
|
|
# distribution, for details about the copyright.
|
|
#
|
|
|
|
## This module implements semantic checking for calls.
|
|
# included from sem.nim
|
|
|
|
from std/algorithm import sort
|
|
|
|
|
|
proc sameMethodDispatcher(a, b: PSym): bool =
|
|
result = false
|
|
if a.kind == skMethod and b.kind == skMethod:
|
|
var aa = lastSon(a.ast)
|
|
var bb = lastSon(b.ast)
|
|
if aa.kind == nkSym and bb.kind == nkSym:
|
|
if aa.sym == bb.sym:
|
|
result = true
|
|
else:
|
|
discard
|
|
# generics have no dispatcher yet, so we need to compare the method
|
|
# names; however, the names are equal anyway because otherwise we
|
|
# wouldn't even consider them to be overloaded. But even this does
|
|
# not work reliably! See tmultim6 for an example:
|
|
# method collide[T](a: TThing, b: TUnit[T]) is instantiated and not
|
|
# method collide[T](a: TUnit[T], b: TThing)! This means we need to
|
|
# *instantiate* every candidate! However, we don't keep more than 2-3
|
|
# candidates around so we cannot implement that for now. So in order
|
|
# to avoid subtle problems, the call remains ambiguous and needs to
|
|
# be disambiguated by the programmer; this way the right generic is
|
|
# instantiated.
|
|
|
|
proc determineType(c: PContext, s: PSym)
|
|
|
|
proc initCandidateSymbols(c: PContext, headSymbol: PNode,
|
|
initialBinding: PNode,
|
|
filter: TSymKinds,
|
|
best, alt: var TCandidate,
|
|
o: var TOverloadIter,
|
|
diagnostics: bool): seq[tuple[s: PSym, scope: int]] =
|
|
## puts all overloads into a seq and prepares best+alt
|
|
result = @[]
|
|
var symx = initOverloadIter(o, c, headSymbol)
|
|
while symx != nil:
|
|
if symx.kind in filter:
|
|
result.add((symx, o.lastOverloadScope))
|
|
elif symx.kind == skGenericParam:
|
|
#[
|
|
This code handles looking up a generic parameter when it's a static callable.
|
|
For instance:
|
|
proc name[T: static proc()]() = T()
|
|
name[proc() = echo"hello"]()
|
|
]#
|
|
for paramSym in searchScopesAll(c, symx.name, {skConst}):
|
|
let paramTyp = paramSym.typ
|
|
if paramTyp.n.kind == nkSym and paramTyp.n.sym.kind in filter:
|
|
result.add((paramTyp.n.sym, o.lastOverloadScope))
|
|
|
|
symx = nextOverloadIter(o, c, headSymbol)
|
|
if result.len > 0:
|
|
best = initCandidate(c, result[0].s, initialBinding,
|
|
result[0].scope, diagnostics)
|
|
alt = initCandidate(c, result[0].s, initialBinding,
|
|
result[0].scope, diagnostics)
|
|
best.state = csNoMatch
|
|
|
|
proc isAttachableRoutineTo(prc: PSym, arg: PType): bool =
|
|
result = false
|
|
if arg.owner != prc.owner: return false
|
|
for i in 1 ..< prc.typ.len:
|
|
if prc.typ.n[i].kind == nkSym and prc.typ.n[i].sym.ast != nil:
|
|
# has default value, parameter is not considered in type attachment
|
|
continue
|
|
let t = nominalRoot(prc.typ[i])
|
|
if t != nil and t.itemId == arg.itemId:
|
|
# parameter `i` is a nominal type in this module
|
|
# attachable if the nominal root `t` has the same id as `arg`
|
|
return true
|
|
|
|
proc addTypeBoundSymbols(graph: ModuleGraph, arg: PType, name: PIdent,
|
|
filter: TSymKinds, marker: var IntSet,
|
|
syms: var seq[tuple[s: PSym, scope: int]]) =
|
|
# add type bound ops for `name` based on the argument type `arg`
|
|
if arg != nil:
|
|
# argument must be typed first, meaning arguments always
|
|
# matching `untyped` are ignored
|
|
let t = nominalRoot(arg)
|
|
if t != nil and t.owner.kind == skModule:
|
|
# search module for routines attachable to `t`
|
|
let module = t.owner
|
|
var iter = default(ModuleIter)
|
|
var s = initModuleIter(iter, graph, module, name)
|
|
while s != nil:
|
|
if s.kind in filter and s.isAttachableRoutineTo(t) and
|
|
not containsOrIncl(marker, s.id):
|
|
# least priority scope, less than explicit imports:
|
|
syms.add((s, -2))
|
|
s = nextModuleIter(iter, graph)
|
|
|
|
proc pickBestCandidate(c: PContext, headSymbol: PNode,
|
|
n, orig: PNode,
|
|
initialBinding: PNode,
|
|
filter: TSymKinds,
|
|
best, alt: var TCandidate,
|
|
errors: var CandidateErrors,
|
|
diagnosticsFlag: bool,
|
|
errorsEnabled: bool, flags: TExprFlags) =
|
|
# `matches` may find new symbols, so keep track of count
|
|
var symCount = c.currentScope.symbols.counter
|
|
|
|
var o: TOverloadIter = default(TOverloadIter)
|
|
# https://github.com/nim-lang/Nim/issues/21272
|
|
# prevent mutation during iteration by storing them in a seq
|
|
# luckily `initCandidateSymbols` does just that
|
|
var syms = initCandidateSymbols(c, headSymbol, initialBinding, filter,
|
|
best, alt, o, diagnosticsFlag)
|
|
if len(syms) == 0:
|
|
return
|
|
let allowTypeBoundOps = typeBoundOps in c.features and
|
|
# qualified or bound symbols cannot refer to type bound ops
|
|
headSymbol.kind in {nkIdent, nkAccQuoted, nkOpenSymChoice, nkOpenSym}
|
|
var symMarker = initIntSet()
|
|
for s in syms:
|
|
symMarker.incl(s.s.id)
|
|
# current overload being considered
|
|
var sym = syms[0].s
|
|
let name = sym.name
|
|
var scope = syms[0].scope
|
|
|
|
if allowTypeBoundOps:
|
|
for a in 1 ..< n.len:
|
|
# for every already typed argument, add type bound ops
|
|
let arg = n[a]
|
|
addTypeBoundSymbols(c.graph, arg.typ, name, filter, symMarker, syms)
|
|
|
|
# starts at 1 because 0 is already done with setup, only needs checking
|
|
var nextSymIndex = 1
|
|
var z: TCandidate # current candidate
|
|
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
|
|
if c.currentScope.symbols.counter == symCount:
|
|
# may introduce new symbols with caveats described in recalc branch
|
|
matches(c, n, orig, z)
|
|
|
|
if allowTypeBoundOps:
|
|
# this match may have given some arguments new types,
|
|
# in which case add their type bound ops as well
|
|
# type bound ops of arguments always matching `untyped` are not considered
|
|
for x in z.newlyTypedOperands:
|
|
let arg = n[x]
|
|
addTypeBoundSymbols(c.graph, arg.typ, name, filter, symMarker, syms)
|
|
|
|
if z.state == csMatch:
|
|
# little hack so that iterators are preferred over everything else:
|
|
if sym.kind == skIterator:
|
|
if not (efWantIterator notin flags and efWantIterable in flags):
|
|
inc(z.exactMatches, 200)
|
|
else:
|
|
dec(z.exactMatches, 200)
|
|
case best.state
|
|
of csEmpty, csNoMatch: best = z
|
|
of csMatch:
|
|
var cmp = cmpCandidates(best, z)
|
|
if cmp < 0: best = z # x is better than the best so far
|
|
elif cmp == 0: alt = z # x is as good as the best so far
|
|
elif errorsEnabled or z.diagnosticsEnabled:
|
|
errors.add(CandidateError(
|
|
sym: sym,
|
|
firstMismatch: z.firstMismatch,
|
|
diagnostics: z.diagnostics))
|
|
else:
|
|
# this branch feels like a ticking timebomb
|
|
# one of two bad things could happen
|
|
# 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
|
|
|
|
# Symbol table has been modified. Restart and pre-calculate all syms
|
|
# before any further candidate init and compare. SLOW, but rare case.
|
|
syms = initCandidateSymbols(c, headSymbol, initialBinding, filter,
|
|
best, alt, o, diagnosticsFlag)
|
|
symMarker = initIntSet()
|
|
for s in syms:
|
|
symMarker.incl(s.s.id)
|
|
if allowTypeBoundOps:
|
|
for a in 1 ..< n.len:
|
|
# for every already typed argument, add type bound ops
|
|
let arg = n[a]
|
|
addTypeBoundSymbols(c.graph, arg.typ, name, filter, symMarker, syms)
|
|
# reset counter because syms may be in a new order
|
|
symCount = c.currentScope.symbols.counter
|
|
nextSymIndex = 0
|
|
|
|
# just in case, should be impossible though
|
|
if syms.len == 0:
|
|
break
|
|
|
|
if nextSymIndex > high(syms):
|
|
# we have reached the end
|
|
break
|
|
|
|
# advance to next sym
|
|
sym = syms[nextSymIndex].s
|
|
scope = syms[nextSymIndex].scope
|
|
inc(nextSymIndex)
|
|
|
|
|
|
proc effectProblem(f, a: PType; result: var string; c: PContext) =
|
|
if f.kind == tyProc and a.kind == tyProc:
|
|
if tfThread in f.flags and tfThread notin a.flags:
|
|
result.add "\n This expression is not GC-safe. Annotate the " &
|
|
"proc with {.gcsafe.} to get extended error information."
|
|
elif tfNoSideEffect in f.flags and tfNoSideEffect notin a.flags:
|
|
result.add "\n This expression can have side effects. Annotate the " &
|
|
"proc with {.noSideEffect.} to get extended error information."
|
|
else:
|
|
case compatibleEffects(f, a)
|
|
of efCompat: discard
|
|
of efRaisesDiffer:
|
|
result.add "\n The `.raises` requirements differ."
|
|
of efRaisesUnknown:
|
|
result.add "\n The `.raises` requirements differ. Annotate the " &
|
|
"proc with {.raises: [].} to get extended error information."
|
|
of efTagsDiffer:
|
|
result.add "\n The `.tags` requirements differ."
|
|
of efTagsUnknown:
|
|
result.add "\n The `.tags` requirements differ. Annotate the " &
|
|
"proc with {.tags: [].} to get extended error information."
|
|
of efEffectsDelayed:
|
|
result.add "\n The `.effectsOf` annotations differ."
|
|
of efTagsIllegal:
|
|
result.add "\n The `.forbids` requirements caught an illegal tag."
|
|
when defined(drnim):
|
|
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
|
|
# to avoid confusing errors like:
|
|
# got (SslPtr, SocketHandle)
|
|
# but expected one of:
|
|
# openssl.SSL_set_fd(ssl: SslPtr, fd: SocketHandle): cint
|
|
# we do a pre-analysis. If all types produce the same string, we will add
|
|
# module information.
|
|
let proto = describeArgs(c, n, 1, preferName)
|
|
for err in errors:
|
|
var errProto = ""
|
|
let n = err.sym.typ.n
|
|
for i in 1..<n.len:
|
|
var p = n[i]
|
|
if p.kind == nkSym:
|
|
errProto.add(typeToString(p.sym.typ, preferName))
|
|
if i != n.len-1: errProto.add(", ")
|
|
# else: ignore internal error as we're already in error handling mode
|
|
if errProto == proto:
|
|
prefer = preferModuleInfo
|
|
break
|
|
|
|
# we pretend procs are attached to the type of the first
|
|
# argument in order to remove plenty of candidates. This is
|
|
# comparable to what C# does and C# is doing fine.
|
|
var filterOnlyFirst = false
|
|
if optShowAllMismatches notin c.config.globalOptions and verboseTypeMismatch in c.config.legacyFeatures:
|
|
for err in errors:
|
|
if err.firstMismatch.arg > 1:
|
|
filterOnlyFirst = true
|
|
break
|
|
|
|
var maybeWrongSpace = false
|
|
|
|
var candidatesAll: seq[string] = @[]
|
|
var candidates = ""
|
|
var skipped = 0
|
|
for err in errors:
|
|
candidates.setLen 0
|
|
if filterOnlyFirst and err.firstMismatch.arg == 1:
|
|
inc skipped
|
|
continue
|
|
|
|
if verboseTypeMismatch notin c.config.legacyFeatures:
|
|
candidates.add "[" & $err.firstMismatch.arg & "] "
|
|
|
|
if err.sym.kind in routineKinds and err.sym.ast != nil:
|
|
candidates.add(renderTree(err.sym.ast,
|
|
{renderNoBody, renderNoComments, renderNoPragmas}))
|
|
else:
|
|
candidates.add(getProcHeader(c.config, err.sym, prefer))
|
|
candidates.addDeclaredLocMaybe(c.config, err.sym)
|
|
candidates.add("\n")
|
|
const genericParamMismatches = {kGenericParamTypeMismatch, kExtraGenericParam, kMissingGenericParam}
|
|
let isGenericMismatch = err.firstMismatch.kind in genericParamMismatches
|
|
var argList = n
|
|
if isGenericMismatch and n[0].kind == nkBracketExpr:
|
|
argList = n[0]
|
|
let nArg =
|
|
if err.firstMismatch.arg < argList.len:
|
|
argList[err.firstMismatch.arg]
|
|
else:
|
|
nil
|
|
let nameParam = if err.firstMismatch.formal != nil: err.firstMismatch.formal.name.s else: ""
|
|
if n.len > 1:
|
|
if verboseTypeMismatch notin c.config.legacyFeatures:
|
|
case err.firstMismatch.kind
|
|
of kUnknownNamedParam:
|
|
if nArg == nil:
|
|
candidates.add(" unknown named parameter")
|
|
else:
|
|
candidates.add(" unknown named parameter: " & $nArg[0])
|
|
candidates.add "\n"
|
|
of kAlreadyGiven:
|
|
candidates.add(" named param already provided: " & $nArg[0])
|
|
candidates.add "\n"
|
|
of kPositionalAlreadyGiven:
|
|
candidates.add(" positional param was already given as named param")
|
|
candidates.add "\n"
|
|
of kExtraArg:
|
|
candidates.add(" extra argument given")
|
|
candidates.add "\n"
|
|
of kMissingParam:
|
|
candidates.add(" missing parameter: " & nameParam)
|
|
candidates.add "\n"
|
|
of kExtraGenericParam:
|
|
candidates.add(" extra generic param given")
|
|
candidates.add "\n"
|
|
of kMissingGenericParam:
|
|
candidates.add(" missing generic parameter: " & nameParam)
|
|
candidates.add "\n"
|
|
of kVarNeeded:
|
|
doAssert nArg != nil
|
|
doAssert err.firstMismatch.formal != nil
|
|
candidates.add " expression '"
|
|
candidates.add renderNotLValue(nArg)
|
|
candidates.add "' is immutable, not 'var'"
|
|
candidates.add "\n"
|
|
of kTypeMismatch:
|
|
doAssert nArg != nil
|
|
if nArg.kind in nkSymChoices:
|
|
candidates.add ambiguousIdentifierMsg(nArg, indent = 2)
|
|
let wanted = err.firstMismatch.formal.typ
|
|
doAssert err.firstMismatch.formal != nil
|
|
doAssert wanted != nil
|
|
let got = nArg.typ
|
|
if got != nil and got.kind == tyProc and wanted.kind == tyProc:
|
|
# These are proc mismatches so,
|
|
# add the extra explict detail of the mismatch
|
|
candidates.add " expression '"
|
|
candidates.add renderTree(nArg)
|
|
candidates.add "' is of type: "
|
|
candidates.addTypeDeclVerboseMaybe(c.config, got)
|
|
candidates.addPragmaAndCallConvMismatch(wanted, got, c.config)
|
|
effectProblem(wanted, got, candidates, c)
|
|
candidates.add "\n"
|
|
of kGenericParamTypeMismatch:
|
|
let pos = err.firstMismatch.arg
|
|
doAssert n[0].kind == nkBracketExpr and pos < n[0].len
|
|
let arg = n[0][pos]
|
|
doAssert arg != nil
|
|
var wanted = err.firstMismatch.formal.typ
|
|
if wanted.kind == tyGenericParam and wanted.genericParamHasConstraints:
|
|
wanted = wanted.genericConstraint
|
|
let got = arg.typ.skipTypes({tyTypeDesc})
|
|
doAssert err.firstMismatch.formal != nil
|
|
doAssert wanted != nil
|
|
doAssert got != nil
|
|
candidates.add " generic parameter mismatch, expected "
|
|
candidates.addTypeDeclVerboseMaybe(c.config, wanted)
|
|
candidates.add " but got '"
|
|
candidates.add renderTree(arg)
|
|
candidates.add "' of type: "
|
|
candidates.addTypeDeclVerboseMaybe(c.config, got)
|
|
if nArg.kind in nkSymChoices:
|
|
candidates.add "\n"
|
|
candidates.add ambiguousIdentifierMsg(nArg, indent = 2)
|
|
if got != nil and got.kind == tyProc and wanted.kind == tyProc:
|
|
# These are proc mismatches so,
|
|
# add the extra explict detail of the mismatch
|
|
candidates.addPragmaAndCallConvMismatch(wanted, got, c.config)
|
|
if got != nil:
|
|
effectProblem(wanted, got, candidates, c)
|
|
candidates.add "\n"
|
|
of kUnknown: discard "do not break 'nim check'"
|
|
else:
|
|
candidates.add(" first type mismatch at position: " & $err.firstMismatch.arg)
|
|
if err.firstMismatch.kind in genericParamMismatches:
|
|
candidates.add(" in generic parameters")
|
|
# candidates.add "\n reason: " & $err.firstMismatch.kind # for debugging
|
|
case err.firstMismatch.kind
|
|
of kUnknownNamedParam:
|
|
if nArg == nil:
|
|
candidates.add("\n unknown named parameter")
|
|
else:
|
|
candidates.add("\n unknown named parameter: " & $nArg[0])
|
|
of kAlreadyGiven: candidates.add("\n named param already provided: " & $nArg[0])
|
|
of kPositionalAlreadyGiven: candidates.add("\n positional param was already given as named param")
|
|
of kExtraArg: candidates.add("\n extra argument given")
|
|
of kMissingParam: candidates.add("\n missing parameter: " & nameParam)
|
|
of kExtraGenericParam:
|
|
candidates.add("\n extra generic param given")
|
|
of kMissingGenericParam:
|
|
candidates.add("\n missing generic parameter: " & nameParam)
|
|
of kTypeMismatch, kGenericParamTypeMismatch, kVarNeeded:
|
|
doAssert nArg != nil
|
|
var wanted = err.firstMismatch.formal.typ
|
|
if isGenericMismatch and wanted.kind == tyGenericParam and
|
|
wanted.genericParamHasConstraints:
|
|
wanted = wanted.genericConstraint
|
|
doAssert err.firstMismatch.formal != nil
|
|
candidates.add("\n required type for " & nameParam & ": ")
|
|
candidates.addTypeDeclVerboseMaybe(c.config, wanted)
|
|
candidates.add "\n but expression '"
|
|
if err.firstMismatch.kind == kVarNeeded:
|
|
candidates.add renderNotLValue(nArg)
|
|
candidates.add "' is immutable, not 'var'"
|
|
else:
|
|
candidates.add renderTree(nArg)
|
|
candidates.add "' is of type: "
|
|
var got = nArg.typ
|
|
if isGenericMismatch: got = got.skipTypes({tyTypeDesc})
|
|
candidates.addTypeDeclVerboseMaybe(c.config, got)
|
|
if nArg.kind in nkSymChoices:
|
|
candidates.add "\n"
|
|
candidates.add ambiguousIdentifierMsg(nArg, indent = 2)
|
|
doAssert wanted != nil
|
|
if got != nil:
|
|
if got.kind == tyProc and wanted.kind == tyProc:
|
|
# These are proc mismatches so,
|
|
# add the extra explict detail of the mismatch
|
|
candidates.addPragmaAndCallConvMismatch(wanted, got, c.config)
|
|
effectProblem(wanted, got, candidates, c)
|
|
|
|
of kUnknown: discard "do not break 'nim check'"
|
|
candidates.add "\n"
|
|
if err.firstMismatch.arg == 1 and nArg != nil and
|
|
nArg.kind == nkTupleConstr and n.kind == nkCommand:
|
|
maybeWrongSpace = true
|
|
for diag in err.diagnostics:
|
|
candidates.add(diag & "\n")
|
|
candidatesAll.add candidates
|
|
candidatesAll.sort # fix #13538
|
|
candidates = join(candidatesAll)
|
|
if skipped > 0:
|
|
candidates.add($skipped & " other mismatching symbols have been " &
|
|
"suppressed; compile with --showAllMismatches:on to see them\n")
|
|
if maybeWrongSpace:
|
|
candidates.add("maybe misplaced space between " & renderTree(n[0]) & " and '(' \n")
|
|
|
|
result = (prefer, candidates)
|
|
|
|
const
|
|
errTypeMismatch = "type mismatch: got <"
|
|
errButExpected = "but expected one of:"
|
|
errExpectedPosition = "Expected one of (first mismatch at [position]):"
|
|
errUndeclaredField = "undeclared field: '$1'"
|
|
errUndeclaredRoutine = "attempting to call undeclared routine: '$1'"
|
|
errBadRoutine = "attempting to call routine: '$1'$2"
|
|
errAmbiguousCallXYZ = "ambiguous call; both $1 and $2 match for: $3"
|
|
|
|
proc describeParamList(c: PContext, n: PNode, startIdx = 1; prefer = preferName): string =
|
|
result = "Expression: " & $n
|
|
for i in startIdx..<n.len:
|
|
result.add "\n [" & $i & "] " & renderTree(n[i]) & ": "
|
|
result.add describeArg(c, n, i, startIdx, prefer)
|
|
result.add "\n"
|
|
|
|
template legacynotFoundError(c: PContext, n: PNode, errors: CandidateErrors) =
|
|
let (prefer, candidates) = presentFailedCandidates(c, n, errors)
|
|
var result = errTypeMismatch
|
|
result.add(describeArgs(c, n, 1, prefer))
|
|
result.add('>')
|
|
if candidates != "":
|
|
result.add("\n" & errButExpected & "\n" & candidates)
|
|
localError(c.config, n.info, result & "\nexpression: " & $n)
|
|
|
|
proc notFoundError*(c: PContext, n: PNode, errors: CandidateErrors) =
|
|
# Gives a detailed error message; this is separated from semOverloadedCall,
|
|
# as semOverloadedCall is already pretty slow (and we need this information
|
|
# only in case of an error).
|
|
if c.config.m.errorOutputs == {}:
|
|
# fail fast:
|
|
globalError(c.config, n.info, "type mismatch")
|
|
return
|
|
# see getMsgDiagnostic:
|
|
if nfExplicitCall notin n.flags and {nfDotField, nfDotSetter} * n.flags != {}:
|
|
let ident = considerQuotedIdent(c, n[0], n).s
|
|
let sym = n[1].typ.typSym
|
|
var typeHint = ""
|
|
if sym == nil:
|
|
discard
|
|
else:
|
|
typeHint = " for type " & getProcHeader(c.config, sym)
|
|
localError(c.config, n.info, errUndeclaredField % ident & typeHint)
|
|
return
|
|
if errors.len == 0:
|
|
if n[0].kind in nkIdentKinds:
|
|
let ident = considerQuotedIdent(c, n[0], n).s
|
|
localError(c.config, n.info, errUndeclaredRoutine % ident)
|
|
else:
|
|
localError(c.config, n.info, "expression '$1' cannot be called" % n[0].renderTree)
|
|
return
|
|
|
|
if verboseTypeMismatch in c.config.legacyFeatures:
|
|
legacynotFoundError(c, n, errors)
|
|
else:
|
|
let (prefer, candidates) = presentFailedCandidates(c, n, errors)
|
|
var result = "type mismatch\n"
|
|
result.add describeParamList(c, n, 1, prefer)
|
|
if candidates != "":
|
|
result.add("\n" & errExpectedPosition & "\n" & candidates)
|
|
localError(c.config, n.info, result)
|
|
|
|
proc getMsgDiagnostic(c: PContext, flags: TExprFlags, n, f: PNode): string =
|
|
result = ""
|
|
if c.compilesContextId > 0:
|
|
# we avoid running more diagnostic when inside a `compiles(expr)`, to
|
|
# errors while running diagnostic (see test D20180828T234921), and
|
|
# also avoid slowdowns in evaluating `compiles(expr)`.
|
|
discard
|
|
else:
|
|
var o: TOverloadIter = default(TOverloadIter)
|
|
var sym = initOverloadIter(o, c, f)
|
|
while sym != nil:
|
|
result &= "\n found $1" % [getSymRepr(c.config, sym)]
|
|
sym = nextOverloadIter(o, c, f)
|
|
|
|
let ident = considerQuotedIdent(c, f, n).s
|
|
if nfExplicitCall notin n.flags and {nfDotField, nfDotSetter} * n.flags != {}:
|
|
let sym = n[1].typ.typSym
|
|
var typeHint = ""
|
|
if sym == nil:
|
|
# Perhaps we're in a `compiles(foo.bar)` expression, or
|
|
# in a concept, e.g.:
|
|
# ExplainedConcept {.explain.} = concept x
|
|
# x.foo is int
|
|
# We could use: `(c.config $ n[1].info)` to get more context.
|
|
discard
|
|
else:
|
|
typeHint = " for type " & getProcHeader(c.config, sym)
|
|
let suffix = if result.len > 0: " " & result else: ""
|
|
result = errUndeclaredField % ident & typeHint & suffix
|
|
else:
|
|
if result.len == 0: result = errUndeclaredRoutine % ident
|
|
else: result = errBadRoutine % [ident, result]
|
|
|
|
proc resolveOverloads(c: PContext, n, orig: PNode,
|
|
filter: TSymKinds, flags: TExprFlags,
|
|
errors: var CandidateErrors,
|
|
errorsEnabled: bool): TCandidate =
|
|
result = default(TCandidate)
|
|
var initialBinding: PNode
|
|
var alt: TCandidate = default(TCandidate)
|
|
var f = n[0]
|
|
if f.kind == nkBracketExpr:
|
|
# fill in the bindings:
|
|
semOpAux(c, f)
|
|
initialBinding = f
|
|
f = f[0]
|
|
else:
|
|
initialBinding = nil
|
|
|
|
pickBestCandidate(c, f, n, orig, initialBinding,
|
|
filter, result, alt, errors, efExplain in flags,
|
|
errorsEnabled, flags)
|
|
|
|
var dummyErrors: CandidateErrors = @[]
|
|
template pickSpecialOp(headSymbol) =
|
|
pickBestCandidate(c, headSymbol, n, orig, initialBinding,
|
|
filter, result, alt, dummyErrors, efExplain in flags,
|
|
false, flags)
|
|
|
|
let overloadsState = result.state
|
|
if overloadsState != csMatch:
|
|
if nfDotField in n.flags:
|
|
internalAssert c.config, f.kind == nkIdent and n.len >= 2
|
|
|
|
# leave the op head symbol empty,
|
|
# we are going to try multiple variants
|
|
n.sons[0..1] = [nil, n[1], f]
|
|
orig.sons[0..1] = [nil, orig[1], f]
|
|
|
|
template tryOp(x) =
|
|
let op = newIdentNode(getIdent(c.cache, x), n.info)
|
|
n[0] = op
|
|
orig[0] = op
|
|
pickSpecialOp(op)
|
|
|
|
if nfExplicitCall in n.flags:
|
|
tryOp ".()"
|
|
|
|
if result.state in {csEmpty, csNoMatch}:
|
|
tryOp "."
|
|
|
|
elif nfDotSetter in n.flags and f.kind == nkIdent and n.len == 3:
|
|
# we need to strip away the trailing '=' here:
|
|
let calleeName = newIdentNode(getIdent(c.cache, f.ident.s[0..^2]), n.info)
|
|
let callOp = newIdentNode(getIdent(c.cache, ".="), n.info)
|
|
n.sons[0..1] = [callOp, n[1], calleeName]
|
|
orig.sons[0..1] = [callOp, orig[1], calleeName]
|
|
pickSpecialOp(callOp)
|
|
|
|
if overloadsState == csEmpty and result.state == csEmpty:
|
|
if efNoUndeclared notin flags: # for tests/pragmas/tcustom_pragma.nim
|
|
result.state = csNoMatch
|
|
if c.inGenericContext > 0 and nfExprCall in n.flags:
|
|
# untyped expression calls end up here, see #24099
|
|
return
|
|
# xxx adapt/use errorUndeclaredIdentifierHint(c, n, f.ident)
|
|
localError(c.config, n.info, getMsgDiagnostic(c, flags, n, f))
|
|
return
|
|
elif result.state != csMatch:
|
|
if nfExprCall in n.flags:
|
|
localError(c.config, n.info, "expression '$1' cannot be called" %
|
|
renderTree(n, {renderNoComments}))
|
|
else:
|
|
if {nfDotField, nfDotSetter} * n.flags != {}:
|
|
# clean up the inserted ops
|
|
n.sons.delete(2)
|
|
n[0] = f
|
|
return
|
|
if alt.state == csMatch and cmpCandidates(result, alt) == 0 and
|
|
not sameMethodDispatcher(result.calleeSym, alt.calleeSym):
|
|
internalAssert c.config, result.state == csMatch
|
|
#writeMatches(result)
|
|
#writeMatches(alt)
|
|
if c.config.m.errorOutputs == {}:
|
|
# quick error message for performance of 'compiles' built-in:
|
|
globalError(c.config, n.info, errGenerated, "ambiguous call")
|
|
elif c.config.errorCounter == 0:
|
|
# don't cascade errors
|
|
var args = "("
|
|
for i in 1..<n.len:
|
|
if i > 1: args.add(", ")
|
|
args.add(typeToString(n[i].typ))
|
|
args.add(")")
|
|
|
|
localError(c.config, n.info, errAmbiguousCallXYZ % [
|
|
getProcHeader(c.config, result.calleeSym),
|
|
getProcHeader(c.config, alt.calleeSym),
|
|
args])
|
|
|
|
proc bracketNotFoundError(c: PContext; n: PNode; flags: TExprFlags) =
|
|
var errors: CandidateErrors = @[]
|
|
let headSymbol = n[0]
|
|
block:
|
|
# we build a closed symchoice of all `[]` overloads for their errors,
|
|
# except add a custom error for the magics which always match
|
|
var choice = newNodeIT(nkClosedSymChoice, headSymbol.info, newTypeS(tyNone, c))
|
|
var o: TOverloadIter = default(TOverloadIter)
|
|
var symx = initOverloadIter(o, c, headSymbol)
|
|
while symx != nil:
|
|
if symx.kind in routineKinds:
|
|
if symx.magic in {mArrGet, mArrPut}:
|
|
errors.add(CandidateError(sym: symx,
|
|
firstMismatch: MismatchInfo(),
|
|
diagnostics: @[],
|
|
enabled: false))
|
|
else:
|
|
choice.add newSymNode(symx, headSymbol.info)
|
|
symx = nextOverloadIter(o, c, headSymbol)
|
|
n[0] = choice
|
|
# copied from semOverloadedCallAnalyzeEffects, might be overkill:
|
|
const baseFilter = {skProc, skFunc, skMethod, skConverter, skMacro, skTemplate}
|
|
let filter =
|
|
if flags*{efInTypeof, efWantIterator, efWantIterable} != {}:
|
|
baseFilter + {skIterator}
|
|
else: baseFilter
|
|
# this will add the errors:
|
|
var r = resolveOverloads(c, n, n, filter, flags, errors, true)
|
|
if errors.len == 0:
|
|
localError(c.config, n.info, "could not resolve: " & $n)
|
|
else:
|
|
notFoundError(c, n, errors)
|
|
|
|
proc instGenericConvertersArg*(c: PContext, a: PNode, x: TCandidate) =
|
|
let a = if a.kind == nkHiddenDeref: a[0] else: a
|
|
if a.kind == nkHiddenCallConv and a[0].kind == nkSym:
|
|
let s = a[0].sym
|
|
if s.isGenericRoutineStrict:
|
|
let finalCallee = generateInstance(c, s, x.bindings, a.info)
|
|
a[0].sym = finalCallee
|
|
a[0].typ() = finalCallee.typ
|
|
#a.typ = finalCallee.typ.returnType
|
|
|
|
proc instGenericConvertersSons*(c: PContext, n: PNode, x: TCandidate) =
|
|
assert n.kind in nkCallKinds
|
|
if x.genericConverter:
|
|
for i in 1..<n.len:
|
|
instGenericConvertersArg(c, n[i], x)
|
|
|
|
proc markConvertersUsed*(c: PContext, n: PNode) =
|
|
assert n.kind in nkCallKinds
|
|
for i in 1..<n.len:
|
|
var a = n[i]
|
|
if a == nil: continue
|
|
if a.kind == nkHiddenDeref: a = a[0]
|
|
if a.kind == nkHiddenCallConv and a[0].kind == nkSym:
|
|
markUsed(c, a.info, a[0].sym)
|
|
|
|
proc indexTypesMatch(c: PContext, f, a: PType, arg: PNode): PNode =
|
|
var m = newCandidate(c, f)
|
|
result = paramTypesMatch(m, f, a, arg, nil)
|
|
if m.genericConverter and result != nil:
|
|
instGenericConvertersArg(c, result, m)
|
|
|
|
proc inferWithMetatype(c: PContext, formal: PType,
|
|
arg: PNode, coerceDistincts = false): PNode =
|
|
var m = newCandidate(c, formal)
|
|
m.coerceDistincts = coerceDistincts
|
|
result = paramTypesMatch(m, formal, arg.typ, arg, nil)
|
|
if m.genericConverter and result != nil:
|
|
instGenericConvertersArg(c, result, m)
|
|
if result != nil:
|
|
# This almost exactly replicates the steps taken by the compiler during
|
|
# param matching. It performs an embarrassing amount of back-and-forth
|
|
# type jugling, but it's the price to pay for consistency and correctness
|
|
result.typ() = generateTypeInstance(c, m.bindings, arg.info,
|
|
formal.skipTypes({tyCompositeTypeClass}))
|
|
else:
|
|
typeMismatch(c.config, arg.info, formal, arg.typ, arg)
|
|
# error correction:
|
|
result = copyTree(arg)
|
|
result.typ() = formal
|
|
|
|
proc updateDefaultParams(c: PContext, call: PNode) =
|
|
# In generic procs, the default parameter may be unique for each
|
|
# instantiation (see tlateboundgenericparams).
|
|
# After a call is resolved, we need to re-assign any default value
|
|
# that was used during sigmatch. sigmatch is responsible for marking
|
|
# the default params with `nfDefaultParam` and `instantiateProcType`
|
|
# computes correctly the default values for each instantiation.
|
|
let calleeParams = call[0].sym.typ.n
|
|
for i in 1..<call.len:
|
|
if nfDefaultParam in call[i].flags:
|
|
let formal = calleeParams[i].sym
|
|
let def = formal.ast
|
|
if nfDefaultRefsParam in def.flags: call.flags.incl nfDefaultRefsParam
|
|
# mirrored with sigmatch:
|
|
if def.kind == nkEmpty:
|
|
# The default param value is set to empty in `instantiateProcType`
|
|
# when the type of the default expression doesn't match the type
|
|
# of the instantiated proc param:
|
|
pushInfoContext(c.config, call.info, call[0].sym.detailedInfo)
|
|
typeMismatch(c.config, def.info, formal.typ, def.typ, formal.ast)
|
|
popInfoContext(c.config)
|
|
def.typ() = errorType(c)
|
|
call[i] = def
|
|
|
|
proc getCallLineInfo(n: PNode): TLineInfo =
|
|
case n.kind
|
|
of nkAccQuoted, nkBracketExpr, nkCall, nkCallStrLit, nkCommand:
|
|
if len(n) > 0:
|
|
return getCallLineInfo(n[0])
|
|
of nkDotExpr:
|
|
if len(n) > 1:
|
|
return getCallLineInfo(n[1])
|
|
else:
|
|
discard
|
|
result = n.info
|
|
|
|
proc inheritBindings(c: PContext, x: var TCandidate, expectedType: PType) =
|
|
## Helper proc to inherit bound generic parameters from expectedType into x.
|
|
## Does nothing if 'inferGenericTypes' isn't in c.features.
|
|
if inferGenericTypes notin c.features: return
|
|
if expectedType == nil or x.callee.returnType == nil: return # required for inference
|
|
|
|
var
|
|
flatUnbound: seq[PType] = @[]
|
|
flatBound: seq[PType] = @[]
|
|
# seq[(result type, expected type)]
|
|
var typeStack = newSeq[(PType, PType)]()
|
|
|
|
template stackPut(a, b) =
|
|
## skips types and puts the skipped version on stack
|
|
# It might make sense to skip here one by one. It's not part of the main
|
|
# type reduction because the right side normally won't be skipped
|
|
const toSkip = {tyVar, tyLent, tyStatic, tyCompositeTypeClass, tySink}
|
|
let
|
|
x = a.skipTypes(toSkip)
|
|
y = if a.kind notin toSkip: b
|
|
else: b.skipTypes(toSkip)
|
|
typeStack.add((x, y))
|
|
|
|
stackPut(x.callee.returnType, expectedType)
|
|
|
|
while typeStack.len() > 0:
|
|
let (t, u) = typeStack.pop()
|
|
if t == u or t == nil or u == nil or t.kind == tyAnything or u.kind == tyAnything:
|
|
continue
|
|
case t.kind
|
|
of ConcreteTypes, tyGenericInvocation, tyUncheckedArray:
|
|
# XXX This logic makes no sense for `tyUncheckedArray`
|
|
# nested, add all the types to stack
|
|
let
|
|
startIdx = if u.kind in ConcreteTypes: 0 else: 1
|
|
endIdx = min(u.kidsLen() - startIdx, t.kidsLen())
|
|
|
|
for i in startIdx ..< endIdx:
|
|
# early exit with current impl
|
|
if t[i] == nil or u[i] == nil: return
|
|
stackPut(t[i], u[i])
|
|
of tyGenericParam:
|
|
let prebound = x.bindings.lookup(t)
|
|
if prebound != nil:
|
|
continue # Skip param, already bound
|
|
|
|
# fully reduced generic param, bind it
|
|
if t notin flatUnbound:
|
|
flatUnbound.add(t)
|
|
flatBound.add(u)
|
|
else:
|
|
discard
|
|
# update bindings
|
|
for i in 0 ..< flatUnbound.len():
|
|
x.bindings.put(flatUnbound[i], flatBound[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)
|
|
onUse(info, finalCallee)
|
|
assert finalCallee.ast != nil
|
|
if x.matchedErrorType:
|
|
result = x.call
|
|
result[0] = newSymNode(finalCallee, getCallLineInfo(result[0]))
|
|
if containsGenericType(result.typ):
|
|
result.typ() = newTypeS(tyError, c)
|
|
incl result.typ.flags, tfCheckedForDestructor
|
|
return
|
|
let gp = finalCallee.ast[genericParamsPos]
|
|
if gp.isGenericParams:
|
|
if x.calleeSym.kind notin {skMacro, skTemplate}:
|
|
if x.calleeSym.magic in {mArrGet, mArrPut}:
|
|
finalCallee = x.calleeSym
|
|
else:
|
|
c.inheritBindings(x, expectedType)
|
|
finalCallee = generateInstance(c, x.calleeSym, x.bindings, n.info)
|
|
else:
|
|
# For macros and templates, the resolved generic params
|
|
# are added as normal params.
|
|
c.inheritBindings(x, expectedType)
|
|
for s in instantiateGenericParamList(c, gp, x.bindings):
|
|
case s.kind
|
|
of skConst:
|
|
if not s.astdef.isNil:
|
|
x.call.add s.astdef
|
|
else:
|
|
x.call.add c.graph.emptyNode
|
|
of skType:
|
|
var tn = newSymNode(s, n.info)
|
|
# this node will be used in template substitution,
|
|
# pretend this is an untyped node and let regular sem handle the type
|
|
# to prevent problems where a generic parameter is treated as a value
|
|
tn.typ() = nil
|
|
x.call.add tn
|
|
else:
|
|
internalAssert c.config, false
|
|
|
|
result = x.call
|
|
instGenericConvertersSons(c, result, x)
|
|
markConvertersUsed(c, result)
|
|
result[0] = newSymNode(finalCallee, getCallLineInfo(result[0]))
|
|
if finalCallee.magic notin {mArrGet, mArrPut}:
|
|
result.typ() = finalCallee.typ.returnType
|
|
updateDefaultParams(c, result)
|
|
|
|
proc canDeref(n: PNode): bool {.inline.} =
|
|
result = n.len >= 2 and (let t = n[1].typ;
|
|
t != nil and t.skipTypes({tyGenericInst, tyAlias, tySink}).kind in {tyPtr, tyRef})
|
|
|
|
proc tryDeref(n: PNode): PNode =
|
|
result = newNodeI(nkHiddenDeref, n.info)
|
|
result.typ() = n.typ.skipTypes(abstractInst)[0]
|
|
result.add n
|
|
|
|
proc semOverloadedCall(c: PContext, n, nOrig: PNode,
|
|
filter: TSymKinds, flags: TExprFlags;
|
|
expectedType: PType = nil): PNode =
|
|
var errors: CandidateErrors = @[] # if efExplain in flags: @[] else: nil
|
|
var r = resolveOverloads(c, n, nOrig, filter, flags, errors, efExplain in flags)
|
|
if r.state == csMatch:
|
|
# this may be triggered, when the explain pragma is used
|
|
if errors.len > 0:
|
|
let (_, candidates) = presentFailedCandidates(c, n, errors)
|
|
message(c.config, n.info, hintUserRaw,
|
|
"Non-matching candidates for " & renderTree(n) & "\n" &
|
|
candidates)
|
|
result = semResolvedCall(c, r, n, flags, expectedType)
|
|
else:
|
|
if c.inGenericContext > 0 and c.matchedConcept == nil:
|
|
result = semGenericStmt(c, n)
|
|
result.typ() = makeTypeFromExpr(c, result.copyTree)
|
|
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})
|
|
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))
|
|
result = n
|
|
|
|
proc explicitGenericSym(c: PContext, n: PNode, s: PSym, errors: var CandidateErrors, doError: bool): PNode =
|
|
if s.kind in {skTemplate, skMacro}:
|
|
internalError c.config, n.info, "cannot get explicitly instantiated symbol of " &
|
|
(if s.kind == skTemplate: "template" else: "macro")
|
|
# binding has to stay 'nil' for this to work!
|
|
var m = newCandidate(c, s, nil)
|
|
matchGenericParams(m, n, s)
|
|
if m.state != csMatch:
|
|
# state is csMatch only if *all* generic params were matched,
|
|
# including implicit parameters
|
|
if doError:
|
|
errors.add(CandidateError(
|
|
sym: s,
|
|
firstMismatch: m.firstMismatch,
|
|
diagnostics: m.diagnostics))
|
|
return nil
|
|
var newInst = generateInstance(c, s, m.bindings, n.info)
|
|
newInst.typ.flags.excl tfUnresolved
|
|
let info = getCallLineInfo(n)
|
|
markUsed(c, info, s)
|
|
onUse(info, s)
|
|
result = newSymNode(newInst, info)
|
|
|
|
proc setGenericParams(c: PContext, n, expectedParams: PNode) =
|
|
## sems generic params in subscript expression
|
|
for i in 1..<n.len:
|
|
let
|
|
constraint =
|
|
if expectedParams != nil and i <= expectedParams.len:
|
|
expectedParams[i - 1].typ
|
|
else:
|
|
nil
|
|
e = semExprWithType(c, n[i], expectedType = constraint)
|
|
if e.typ == nil:
|
|
n[i].typ() = errorType(c)
|
|
else:
|
|
n[i].typ() = e.typ.skipTypes({tyTypeDesc})
|
|
|
|
proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym, doError: bool): PNode =
|
|
assert n.kind == nkBracketExpr
|
|
setGenericParams(c, n, s.ast[genericParamsPos])
|
|
var s = s
|
|
var a = n[0]
|
|
var errors: CandidateErrors = @[]
|
|
if a.kind == nkSym:
|
|
# common case; check the only candidate has the right
|
|
# number of generic type parameters:
|
|
result = explicitGenericSym(c, n, s, errors, doError)
|
|
if result == nil:
|
|
if c.inGenericContext > 0:
|
|
# same as in semOverloadedCall, make expression untyped,
|
|
# may have failed match due to unresolved types
|
|
result = semGenericStmt(c, n)
|
|
result.typ() = makeTypeFromExpr(c, result.copyTree)
|
|
elif doError:
|
|
notFoundError(c, n, errors)
|
|
elif a.kind in {nkClosedSymChoice, nkOpenSymChoice}:
|
|
# choose the generic proc with the proper number of type parameters.
|
|
result = newNodeI(a.kind, getCallLineInfo(n))
|
|
for i in 0..<a.len:
|
|
var candidate = a[i].sym
|
|
if candidate.kind in {skProc, skMethod, skConverter,
|
|
skFunc, skIterator}:
|
|
let x = explicitGenericSym(c, n, candidate, errors, doError)
|
|
if x != nil: result.add(x)
|
|
elif c.inGenericContext > 0:
|
|
# same as in semOverloadedCall, make expression untyped,
|
|
# may have failed match due to unresolved types
|
|
# any failing match stops building the symchoice for correctness,
|
|
# can also make it untyped from the start
|
|
result = semGenericStmt(c, n)
|
|
result.typ() = makeTypeFromExpr(c, result.copyTree)
|
|
return
|
|
# get rid of nkClosedSymChoice if not ambiguous:
|
|
if result.len == 0:
|
|
result = nil
|
|
if doError:
|
|
notFoundError(c, n, errors)
|
|
else:
|
|
# probably unreachable: we are trying to instantiate `a` which is not
|
|
# a sym/symchoice
|
|
if doError:
|
|
result = explicitGenericInstError(c, n)
|
|
else:
|
|
result = nil
|
|
|
|
proc searchForBorrowProc(c: PContext, startScope: PScope, fn: PSym): tuple[s: PSym, state: TBorrowState] =
|
|
# Searches for the fn in the symbol table. If the parameter lists are suitable
|
|
# for borrowing the sym in the symbol table is returned, else nil.
|
|
# New approach: generate fn(x, y, z) where x, y, z have the proper types
|
|
# and use the overloading resolution mechanism:
|
|
const desiredTypes = abstractVar + {tyCompositeTypeClass} - {tyTypeDesc, tyDistinct}
|
|
|
|
template getType(isDistinct: bool; t: PType):untyped =
|
|
if isDistinct: t.baseOfDistinct(c.graph, c.idgen) else: t
|
|
|
|
result = default(tuple[s: PSym, state: TBorrowState])
|
|
var call = newNodeI(nkCall, fn.info)
|
|
var hasDistinct = false
|
|
var isDistinct: bool
|
|
var x: PType
|
|
var t: PType
|
|
call.add(newIdentNode(fn.name, fn.info))
|
|
for i in 1..<fn.typ.n.len:
|
|
let param = fn.typ.n[i]
|
|
#[.
|
|
# We only want the type not any modifiers such as `ptr`, `var`, `ref` ...
|
|
# tyCompositeTypeClass is here for
|
|
# when using something like:
|
|
type Foo[T] = distinct int
|
|
proc `$`(f: Foo): string {.borrow.}
|
|
# We want to skip the `Foo` to get `int`
|
|
]#
|
|
t = skipTypes(param.typ, desiredTypes)
|
|
isDistinct = t.kind == tyDistinct or param.typ.kind == tyDistinct
|
|
if t.kind == tyGenericInvocation and t.genericHead.last.kind == tyDistinct:
|
|
result.state = bsGeneric
|
|
return
|
|
if isDistinct: hasDistinct = true
|
|
if param.typ.kind == tyVar:
|
|
x = newTypeS(param.typ.kind, c)
|
|
x.addSonSkipIntLit(getType(isDistinct, t), c.idgen)
|
|
else:
|
|
x = getType(isDistinct, t)
|
|
var s = copySym(param.sym, c.idgen)
|
|
s.typ = x
|
|
s.info = param.info
|
|
call.add(newSymNode(s))
|
|
if hasDistinct:
|
|
let filter = if fn.kind in {skProc, skFunc}: {skProc, skFunc} else: {fn.kind}
|
|
var resolved = semOverloadedCall(c, call, call, filter, {})
|
|
if resolved != nil:
|
|
result.s = resolved[0].sym
|
|
result.state = bsMatch
|
|
if not compareTypes(result.s.typ.returnType, fn.typ.returnType, dcEqIgnoreDistinct, {IgnoreFlags}):
|
|
result.state = bsReturnNotMatch
|
|
elif result.s.magic in {mArrPut, mArrGet}:
|
|
# cannot borrow these magics for now
|
|
result.state = bsNotSupported
|
|
else:
|
|
result.state = bsNoDistinct
|