semcall.nim 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707
  1. #
  2. #
  3. # The Nim Compiler
  4. # (c) Copyright 2013 Andreas Rumpf
  5. #
  6. # See the file "copying.txt", included in this
  7. # distribution, for details about the copyright.
  8. #
  9. ## This module implements semantic checking for calls.
  10. # included from sem.nim
  11. from algorithm import sort
  12. proc sameMethodDispatcher(a, b: PSym): bool =
  13. result = false
  14. if a.kind == skMethod and b.kind == skMethod:
  15. var aa = lastSon(a.ast)
  16. var bb = lastSon(b.ast)
  17. if aa.kind == nkSym and bb.kind == nkSym:
  18. if aa.sym == bb.sym:
  19. result = true
  20. else:
  21. discard
  22. # generics have no dispatcher yet, so we need to compare the method
  23. # names; however, the names are equal anyway because otherwise we
  24. # wouldn't even consider them to be overloaded. But even this does
  25. # not work reliably! See tmultim6 for an example:
  26. # method collide[T](a: TThing, b: TUnit[T]) is instantiated and not
  27. # method collide[T](a: TUnit[T], b: TThing)! This means we need to
  28. # *instantiate* every candidate! However, we don't keep more than 2-3
  29. # candidates around so we cannot implement that for now. So in order
  30. # to avoid subtle problems, the call remains ambiguous and needs to
  31. # be disambiguated by the programmer; this way the right generic is
  32. # instantiated.
  33. proc determineType(c: PContext, s: PSym)
  34. proc initCandidateSymbols(c: PContext, headSymbol: PNode,
  35. initialBinding: PNode,
  36. filter: TSymKinds,
  37. best, alt: var TCandidate,
  38. o: var TOverloadIter,
  39. diagnostics: bool): seq[tuple[s: PSym, scope: int]] =
  40. result = @[]
  41. var symx = initOverloadIter(o, c, headSymbol)
  42. while symx != nil:
  43. if symx.kind in filter:
  44. result.add((symx, o.lastOverloadScope))
  45. symx = nextOverloadIter(o, c, headSymbol)
  46. if result.len > 0:
  47. initCandidate(c, best, result[0].s, initialBinding,
  48. result[0].scope, diagnostics)
  49. initCandidate(c, alt, result[0].s, initialBinding,
  50. result[0].scope, diagnostics)
  51. best.state = csNoMatch
  52. proc pickBestCandidate(c: PContext, headSymbol: PNode,
  53. n, orig: PNode,
  54. initialBinding: PNode,
  55. filter: TSymKinds,
  56. best, alt: var TCandidate,
  57. errors: var CandidateErrors,
  58. diagnosticsFlag: bool,
  59. errorsEnabled: bool, flags: TExprFlags) =
  60. var o: TOverloadIter
  61. var sym = initOverloadIter(o, c, headSymbol)
  62. var scope = o.lastOverloadScope
  63. # Thanks to the lazy semchecking for operands, we need to check whether
  64. # 'initCandidate' modifies the symbol table (via semExpr).
  65. # This can occur in cases like 'init(a, 1, (var b = new(Type2); b))'
  66. let counterInitial = c.currentScope.symbols.counter
  67. var syms: seq[tuple[s: PSym, scope: int]]
  68. var noSyms = true
  69. var nextSymIndex = 0
  70. while sym != nil:
  71. if sym.kind in filter:
  72. # Initialise 'best' and 'alt' with the first available symbol
  73. initCandidate(c, best, sym, initialBinding, scope, diagnosticsFlag)
  74. initCandidate(c, alt, sym, initialBinding, scope, diagnosticsFlag)
  75. best.state = csNoMatch
  76. break
  77. else:
  78. sym = nextOverloadIter(o, c, headSymbol)
  79. scope = o.lastOverloadScope
  80. var z: TCandidate
  81. while sym != nil:
  82. if sym.kind notin filter:
  83. sym = nextOverloadIter(o, c, headSymbol)
  84. scope = o.lastOverloadScope
  85. continue
  86. determineType(c, sym)
  87. initCandidate(c, z, sym, initialBinding, scope, diagnosticsFlag)
  88. if c.currentScope.symbols.counter == counterInitial or syms.len != 0:
  89. matches(c, n, orig, z)
  90. if z.state == csMatch:
  91. # little hack so that iterators are preferred over everything else:
  92. if sym.kind == skIterator:
  93. if not (efWantIterator notin flags and efWantIterable in flags):
  94. inc(z.exactMatches, 200)
  95. else:
  96. dec(z.exactMatches, 200)
  97. case best.state
  98. of csEmpty, csNoMatch: best = z
  99. of csMatch:
  100. var cmp = cmpCandidates(best, z)
  101. if cmp < 0: best = z # x is better than the best so far
  102. elif cmp == 0: alt = z # x is as good as the best so far
  103. elif errorsEnabled or z.diagnosticsEnabled:
  104. errors.add(CandidateError(
  105. sym: sym,
  106. firstMismatch: z.firstMismatch,
  107. diagnostics: z.diagnostics))
  108. else:
  109. # Symbol table has been modified. Restart and pre-calculate all syms
  110. # before any further candidate init and compare. SLOW, but rare case.
  111. syms = initCandidateSymbols(c, headSymbol, initialBinding, filter,
  112. best, alt, o, diagnosticsFlag)
  113. noSyms = false
  114. if noSyms:
  115. sym = nextOverloadIter(o, c, headSymbol)
  116. scope = o.lastOverloadScope
  117. elif nextSymIndex < syms.len:
  118. # rare case: retrieve the next pre-calculated symbol
  119. sym = syms[nextSymIndex].s
  120. scope = syms[nextSymIndex].scope
  121. nextSymIndex += 1
  122. else:
  123. break
  124. proc effectProblem(f, a: PType; result: var string; c: PContext) =
  125. if f.kind == tyProc and a.kind == tyProc:
  126. if tfThread in f.flags and tfThread notin a.flags:
  127. result.add "\n This expression is not GC-safe. Annotate the " &
  128. "proc with {.gcsafe.} to get extended error information."
  129. elif tfNoSideEffect in f.flags and tfNoSideEffect notin a.flags:
  130. result.add "\n This expression can have side effects. Annotate the " &
  131. "proc with {.noSideEffect.} to get extended error information."
  132. else:
  133. case compatibleEffects(f, a)
  134. of efCompat: discard
  135. of efRaisesDiffer:
  136. result.add "\n The `.raises` requirements differ."
  137. of efRaisesUnknown:
  138. result.add "\n The `.raises` requirements differ. Annotate the " &
  139. "proc with {.raises: [].} to get extended error information."
  140. of efTagsDiffer:
  141. result.add "\n The `.tags` requirements differ."
  142. of efTagsUnknown:
  143. result.add "\n The `.tags` requirements differ. Annotate the " &
  144. "proc with {.tags: [].} to get extended error information."
  145. of efEffectsDelayed:
  146. result.add "\n The `.effectsOf` annotations differ."
  147. of efTagsIllegal:
  148. result.add "\n The `.forbids` requirements caught an illegal tag."
  149. when defined(drnim):
  150. if not c.graph.compatibleProps(c.graph, f, a):
  151. result.add "\n The `.requires` or `.ensures` properties are incompatible."
  152. proc renderNotLValue(n: PNode): string =
  153. result = $n
  154. let n = if n.kind == nkHiddenDeref: n[0] else: n
  155. if n.kind == nkHiddenCallConv and n.len > 1:
  156. result = $n[0] & "(" & result & ")"
  157. elif n.kind in {nkHiddenStdConv, nkHiddenSubConv} and n.len == 2:
  158. result = typeToString(n.typ.skipTypes(abstractVar)) & "(" & result & ")"
  159. proc presentFailedCandidates(c: PContext, n: PNode, errors: CandidateErrors):
  160. (TPreferedDesc, string) =
  161. var prefer = preferName
  162. # to avoid confusing errors like:
  163. # got (SslPtr, SocketHandle)
  164. # but expected one of:
  165. # openssl.SSL_set_fd(ssl: SslPtr, fd: SocketHandle): cint
  166. # we do a pre-analysis. If all types produce the same string, we will add
  167. # module information.
  168. let proto = describeArgs(c, n, 1, preferName)
  169. for err in errors:
  170. var errProto = ""
  171. let n = err.sym.typ.n
  172. for i in 1..<n.len:
  173. var p = n[i]
  174. if p.kind == nkSym:
  175. errProto.add(typeToString(p.sym.typ, preferName))
  176. if i != n.len-1: errProto.add(", ")
  177. # else: ignore internal error as we're already in error handling mode
  178. if errProto == proto:
  179. prefer = preferModuleInfo
  180. break
  181. # we pretend procs are attached to the type of the first
  182. # argument in order to remove plenty of candidates. This is
  183. # comparable to what C# does and C# is doing fine.
  184. var filterOnlyFirst = false
  185. if optShowAllMismatches notin c.config.globalOptions:
  186. for err in errors:
  187. if err.firstMismatch.arg > 1:
  188. filterOnlyFirst = true
  189. break
  190. var maybeWrongSpace = false
  191. var candidatesAll: seq[string]
  192. var candidates = ""
  193. var skipped = 0
  194. for err in errors:
  195. candidates.setLen 0
  196. if filterOnlyFirst and err.firstMismatch.arg == 1:
  197. inc skipped
  198. continue
  199. if err.sym.kind in routineKinds and err.sym.ast != nil:
  200. candidates.add(renderTree(err.sym.ast,
  201. {renderNoBody, renderNoComments, renderNoPragmas}))
  202. else:
  203. candidates.add(getProcHeader(c.config, err.sym, prefer))
  204. candidates.addDeclaredLocMaybe(c.config, err.sym)
  205. candidates.add("\n")
  206. let nArg = if err.firstMismatch.arg < n.len: n[err.firstMismatch.arg] else: nil
  207. let nameParam = if err.firstMismatch.formal != nil: err.firstMismatch.formal.name.s else: ""
  208. if n.len > 1:
  209. candidates.add(" first type mismatch at position: " & $err.firstMismatch.arg)
  210. # candidates.add "\n reason: " & $err.firstMismatch.kind # for debugging
  211. case err.firstMismatch.kind
  212. of kUnknownNamedParam:
  213. if nArg == nil:
  214. candidates.add("\n unknown named parameter")
  215. else:
  216. candidates.add("\n unknown named parameter: " & $nArg[0])
  217. of kAlreadyGiven: candidates.add("\n named param already provided: " & $nArg[0])
  218. of kPositionalAlreadyGiven: candidates.add("\n positional param was already given as named param")
  219. of kExtraArg: candidates.add("\n extra argument given")
  220. of kMissingParam: candidates.add("\n missing parameter: " & nameParam)
  221. of kTypeMismatch, kVarNeeded:
  222. doAssert nArg != nil
  223. let wanted = err.firstMismatch.formal.typ
  224. doAssert err.firstMismatch.formal != nil
  225. candidates.add("\n required type for " & nameParam & ": ")
  226. candidates.addTypeDeclVerboseMaybe(c.config, wanted)
  227. candidates.add "\n but expression '"
  228. if err.firstMismatch.kind == kVarNeeded:
  229. candidates.add renderNotLValue(nArg)
  230. candidates.add "' is immutable, not 'var'"
  231. else:
  232. candidates.add renderTree(nArg)
  233. candidates.add "' is of type: "
  234. let got = nArg.typ
  235. candidates.addTypeDeclVerboseMaybe(c.config, got)
  236. doAssert wanted != nil
  237. if got != nil:
  238. if got.kind == tyProc and wanted.kind == tyProc:
  239. # These are proc mismatches so,
  240. # add the extra explict detail of the mismatch
  241. candidates.addPragmaAndCallConvMismatch(wanted, got, c.config)
  242. effectProblem(wanted, got, candidates, c)
  243. of kUnknown: discard "do not break 'nim check'"
  244. candidates.add "\n"
  245. if err.firstMismatch.arg == 1 and nArg.kind == nkTupleConstr and
  246. n.kind == nkCommand:
  247. maybeWrongSpace = true
  248. for diag in err.diagnostics:
  249. candidates.add(diag & "\n")
  250. candidatesAll.add candidates
  251. candidatesAll.sort # fix #13538
  252. candidates = join(candidatesAll)
  253. if skipped > 0:
  254. candidates.add($skipped & " other mismatching symbols have been " &
  255. "suppressed; compile with --showAllMismatches:on to see them\n")
  256. if maybeWrongSpace:
  257. candidates.add("maybe misplaced space between " & renderTree(n[0]) & " and '(' \n")
  258. result = (prefer, candidates)
  259. const
  260. errTypeMismatch = "type mismatch: got <"
  261. errButExpected = "but expected one of:"
  262. errUndeclaredField = "undeclared field: '$1'"
  263. errUndeclaredRoutine = "attempting to call undeclared routine: '$1'"
  264. errBadRoutine = "attempting to call routine: '$1'$2"
  265. errAmbiguousCallXYZ = "ambiguous call; both $1 and $2 match for: $3"
  266. proc notFoundError*(c: PContext, n: PNode, errors: CandidateErrors) =
  267. # Gives a detailed error message; this is separated from semOverloadedCall,
  268. # as semOverloadedCall is already pretty slow (and we need this information
  269. # only in case of an error).
  270. if c.config.m.errorOutputs == {}:
  271. # fail fast:
  272. globalError(c.config, n.info, "type mismatch")
  273. return
  274. # see getMsgDiagnostic:
  275. if nfExplicitCall notin n.flags and {nfDotField, nfDotSetter} * n.flags != {}:
  276. let ident = considerQuotedIdent(c, n[0], n).s
  277. let sym = n[1].typ.typSym
  278. var typeHint = ""
  279. if sym == nil:
  280. discard
  281. else:
  282. typeHint = " for type " & getProcHeader(c.config, sym)
  283. localError(c.config, n.info, errUndeclaredField % ident & typeHint)
  284. return
  285. if errors.len == 0:
  286. if n[0].kind in nkIdentKinds:
  287. let ident = considerQuotedIdent(c, n[0], n).s
  288. localError(c.config, n.info, errUndeclaredRoutine % ident)
  289. else:
  290. localError(c.config, n.info, "expression '$1' cannot be called" % n[0].renderTree)
  291. return
  292. let (prefer, candidates) = presentFailedCandidates(c, n, errors)
  293. var result = errTypeMismatch
  294. result.add(describeArgs(c, n, 1, prefer))
  295. result.add('>')
  296. if candidates != "":
  297. result.add("\n" & errButExpected & "\n" & candidates)
  298. localError(c.config, n.info, result & "\nexpression: " & $n)
  299. proc bracketNotFoundError(c: PContext; n: PNode) =
  300. var errors: CandidateErrors = @[]
  301. var o: TOverloadIter
  302. let headSymbol = n[0]
  303. var symx = initOverloadIter(o, c, headSymbol)
  304. while symx != nil:
  305. if symx.kind in routineKinds:
  306. errors.add(CandidateError(sym: symx,
  307. firstMismatch: MismatchInfo(),
  308. diagnostics: @[],
  309. enabled: false))
  310. symx = nextOverloadIter(o, c, headSymbol)
  311. if errors.len == 0:
  312. localError(c.config, n.info, "could not resolve: " & $n)
  313. else:
  314. notFoundError(c, n, errors)
  315. proc getMsgDiagnostic(c: PContext, flags: TExprFlags, n, f: PNode): string =
  316. if c.compilesContextId > 0:
  317. # we avoid running more diagnostic when inside a `compiles(expr)`, to
  318. # errors while running diagnostic (see test D20180828T234921), and
  319. # also avoid slowdowns in evaluating `compiles(expr)`.
  320. discard
  321. else:
  322. var o: TOverloadIter
  323. var sym = initOverloadIter(o, c, f)
  324. while sym != nil:
  325. result &= "\n found $1" % [getSymRepr(c.config, sym)]
  326. sym = nextOverloadIter(o, c, f)
  327. let ident = considerQuotedIdent(c, f, n).s
  328. if nfExplicitCall notin n.flags and {nfDotField, nfDotSetter} * n.flags != {}:
  329. let sym = n[1].typ.typSym
  330. var typeHint = ""
  331. if sym == nil:
  332. # Perhaps we're in a `compiles(foo.bar)` expression, or
  333. # in a concept, e.g.:
  334. # ExplainedConcept {.explain.} = concept x
  335. # x.foo is int
  336. # We could use: `(c.config $ n[1].info)` to get more context.
  337. discard
  338. else:
  339. typeHint = " for type " & getProcHeader(c.config, sym)
  340. let suffix = if result.len > 0: " " & result else: ""
  341. result = errUndeclaredField % ident & typeHint & suffix
  342. else:
  343. if result.len == 0: result = errUndeclaredRoutine % ident
  344. else: result = errBadRoutine % [ident, result]
  345. proc resolveOverloads(c: PContext, n, orig: PNode,
  346. filter: TSymKinds, flags: TExprFlags,
  347. errors: var CandidateErrors,
  348. errorsEnabled: bool): TCandidate =
  349. var initialBinding: PNode
  350. var alt: TCandidate
  351. var f = n[0]
  352. if f.kind == nkBracketExpr:
  353. # fill in the bindings:
  354. semOpAux(c, f)
  355. initialBinding = f
  356. f = f[0]
  357. else:
  358. initialBinding = nil
  359. pickBestCandidate(c, f, n, orig, initialBinding,
  360. filter, result, alt, errors, efExplain in flags,
  361. errorsEnabled, flags)
  362. var dummyErrors: CandidateErrors
  363. template pickSpecialOp(headSymbol) =
  364. pickBestCandidate(c, headSymbol, n, orig, initialBinding,
  365. filter, result, alt, dummyErrors, efExplain in flags,
  366. false, flags)
  367. let overloadsState = result.state
  368. if overloadsState != csMatch:
  369. if nfDotField in n.flags:
  370. internalAssert c.config, f.kind == nkIdent and n.len >= 2
  371. # leave the op head symbol empty,
  372. # we are going to try multiple variants
  373. n.sons[0..1] = [nil, n[1], f]
  374. orig.sons[0..1] = [nil, orig[1], f]
  375. template tryOp(x) =
  376. let op = newIdentNode(getIdent(c.cache, x), n.info)
  377. n[0] = op
  378. orig[0] = op
  379. pickSpecialOp(op)
  380. if nfExplicitCall in n.flags:
  381. tryOp ".()"
  382. if result.state in {csEmpty, csNoMatch}:
  383. tryOp "."
  384. elif nfDotSetter in n.flags and f.kind == nkIdent and n.len == 3:
  385. # we need to strip away the trailing '=' here:
  386. let calleeName = newIdentNode(getIdent(c.cache, f.ident.s[0..^2]), n.info)
  387. let callOp = newIdentNode(getIdent(c.cache, ".="), n.info)
  388. n.sons[0..1] = [callOp, n[1], calleeName]
  389. orig.sons[0..1] = [callOp, orig[1], calleeName]
  390. pickSpecialOp(callOp)
  391. if overloadsState == csEmpty and result.state == csEmpty:
  392. if efNoUndeclared notin flags: # for tests/pragmas/tcustom_pragma.nim
  393. result.state = csNoMatch
  394. if efNoDiagnostics in flags:
  395. return
  396. # xxx adapt/use errorUndeclaredIdentifierHint(c, n, f.ident)
  397. localError(c.config, n.info, getMsgDiagnostic(c, flags, n, f))
  398. return
  399. elif result.state != csMatch:
  400. if nfExprCall in n.flags:
  401. localError(c.config, n.info, "expression '$1' cannot be called" %
  402. renderTree(n, {renderNoComments}))
  403. else:
  404. if {nfDotField, nfDotSetter} * n.flags != {}:
  405. # clean up the inserted ops
  406. n.sons.delete(2)
  407. n[0] = f
  408. return
  409. if alt.state == csMatch and cmpCandidates(result, alt) == 0 and
  410. not sameMethodDispatcher(result.calleeSym, alt.calleeSym):
  411. internalAssert c.config, result.state == csMatch
  412. #writeMatches(result)
  413. #writeMatches(alt)
  414. if c.config.m.errorOutputs == {}:
  415. # quick error message for performance of 'compiles' built-in:
  416. globalError(c.config, n.info, errGenerated, "ambiguous call")
  417. elif c.config.errorCounter == 0:
  418. # don't cascade errors
  419. var args = "("
  420. for i in 1..<n.len:
  421. if i > 1: args.add(", ")
  422. args.add(typeToString(n[i].typ))
  423. args.add(")")
  424. localError(c.config, n.info, errAmbiguousCallXYZ % [
  425. getProcHeader(c.config, result.calleeSym),
  426. getProcHeader(c.config, alt.calleeSym),
  427. args])
  428. proc instGenericConvertersArg*(c: PContext, a: PNode, x: TCandidate) =
  429. let a = if a.kind == nkHiddenDeref: a[0] else: a
  430. if a.kind == nkHiddenCallConv and a[0].kind == nkSym:
  431. let s = a[0].sym
  432. if s.isGenericRoutineStrict:
  433. let finalCallee = generateInstance(c, s, x.bindings, a.info)
  434. a[0].sym = finalCallee
  435. a[0].typ = finalCallee.typ
  436. #a.typ = finalCallee.typ[0]
  437. proc instGenericConvertersSons*(c: PContext, n: PNode, x: TCandidate) =
  438. assert n.kind in nkCallKinds
  439. if x.genericConverter:
  440. for i in 1..<n.len:
  441. instGenericConvertersArg(c, n[i], x)
  442. proc indexTypesMatch(c: PContext, f, a: PType, arg: PNode): PNode =
  443. var m = newCandidate(c, f)
  444. result = paramTypesMatch(m, f, a, arg, nil)
  445. if m.genericConverter and result != nil:
  446. instGenericConvertersArg(c, result, m)
  447. proc inferWithMetatype(c: PContext, formal: PType,
  448. arg: PNode, coerceDistincts = false): PNode =
  449. var m = newCandidate(c, formal)
  450. m.coerceDistincts = coerceDistincts
  451. result = paramTypesMatch(m, formal, arg.typ, arg, nil)
  452. if m.genericConverter and result != nil:
  453. instGenericConvertersArg(c, result, m)
  454. if result != nil:
  455. # This almost exactly replicates the steps taken by the compiler during
  456. # param matching. It performs an embarrassing amount of back-and-forth
  457. # type jugling, but it's the price to pay for consistency and correctness
  458. result.typ = generateTypeInstance(c, m.bindings, arg.info,
  459. formal.skipTypes({tyCompositeTypeClass}))
  460. else:
  461. typeMismatch(c.config, arg.info, formal, arg.typ, arg)
  462. # error correction:
  463. result = copyTree(arg)
  464. result.typ = formal
  465. proc updateDefaultParams(call: PNode) =
  466. # In generic procs, the default parameter may be unique for each
  467. # instantiation (see tlateboundgenericparams).
  468. # After a call is resolved, we need to re-assign any default value
  469. # that was used during sigmatch. sigmatch is responsible for marking
  470. # the default params with `nfDefaultParam` and `instantiateProcType`
  471. # computes correctly the default values for each instantiation.
  472. let calleeParams = call[0].sym.typ.n
  473. for i in 1..<call.len:
  474. if nfDefaultParam in call[i].flags:
  475. let def = calleeParams[i].sym.ast
  476. if nfDefaultRefsParam in def.flags: call.flags.incl nfDefaultRefsParam
  477. call[i] = def
  478. proc getCallLineInfo(n: PNode): TLineInfo =
  479. case n.kind
  480. of nkAccQuoted, nkBracketExpr, nkCall, nkCallStrLit, nkCommand:
  481. if len(n) > 0:
  482. return getCallLineInfo(n[0])
  483. of nkDotExpr:
  484. if len(n) > 1:
  485. return getCallLineInfo(n[1])
  486. else:
  487. discard
  488. result = n.info
  489. proc semResolvedCall(c: PContext, x: TCandidate,
  490. n: PNode, flags: TExprFlags): PNode =
  491. assert x.state == csMatch
  492. var finalCallee = x.calleeSym
  493. let info = getCallLineInfo(n)
  494. markUsed(c, info, finalCallee)
  495. onUse(info, finalCallee)
  496. assert finalCallee.ast != nil
  497. if x.hasFauxMatch:
  498. result = x.call
  499. result[0] = newSymNode(finalCallee, getCallLineInfo(result[0]))
  500. if containsGenericType(result.typ) or x.fauxMatch == tyUnknown:
  501. result.typ = newTypeS(x.fauxMatch, c)
  502. if result.typ.kind == tyError: incl result.typ.flags, tfCheckedForDestructor
  503. return
  504. let gp = finalCallee.ast[genericParamsPos]
  505. if gp.isGenericParams:
  506. if x.calleeSym.kind notin {skMacro, skTemplate}:
  507. if x.calleeSym.magic in {mArrGet, mArrPut}:
  508. finalCallee = x.calleeSym
  509. else:
  510. finalCallee = generateInstance(c, x.calleeSym, x.bindings, n.info)
  511. else:
  512. # For macros and templates, the resolved generic params
  513. # are added as normal params.
  514. for s in instantiateGenericParamList(c, gp, x.bindings):
  515. case s.kind
  516. of skConst:
  517. if not s.astdef.isNil:
  518. x.call.add s.astdef
  519. else:
  520. x.call.add c.graph.emptyNode
  521. of skType:
  522. x.call.add newSymNode(s, n.info)
  523. else:
  524. internalAssert c.config, false
  525. result = x.call
  526. instGenericConvertersSons(c, result, x)
  527. result[0] = newSymNode(finalCallee, getCallLineInfo(result[0]))
  528. result.typ = finalCallee.typ[0]
  529. updateDefaultParams(result)
  530. proc canDeref(n: PNode): bool {.inline.} =
  531. result = n.len >= 2 and (let t = n[1].typ;
  532. t != nil and t.skipTypes({tyGenericInst, tyAlias, tySink}).kind in {tyPtr, tyRef})
  533. proc tryDeref(n: PNode): PNode =
  534. result = newNodeI(nkHiddenDeref, n.info)
  535. result.typ = n.typ.skipTypes(abstractInst)[0]
  536. result.add n
  537. proc semOverloadedCall(c: PContext, n, nOrig: PNode,
  538. filter: TSymKinds, flags: TExprFlags): PNode {.nosinks.} =
  539. var errors: CandidateErrors = @[] # if efExplain in flags: @[] else: nil
  540. var r = resolveOverloads(c, n, nOrig, filter, flags, errors, efExplain in flags)
  541. if r.state == csMatch:
  542. # this may be triggered, when the explain pragma is used
  543. if errors.len > 0:
  544. let (_, candidates) = presentFailedCandidates(c, n, errors)
  545. message(c.config, n.info, hintUserRaw,
  546. "Non-matching candidates for " & renderTree(n) & "\n" &
  547. candidates)
  548. result = semResolvedCall(c, r, n, flags)
  549. else:
  550. if efExplain notin flags:
  551. # repeat the overload resolution,
  552. # this time enabling all the diagnostic output (this should fail again)
  553. discard semOverloadedCall(c, n, nOrig, filter, flags + {efExplain})
  554. elif efNoUndeclared notin flags:
  555. notFoundError(c, n, errors)
  556. proc explicitGenericInstError(c: PContext; n: PNode): PNode =
  557. localError(c.config, getCallLineInfo(n), errCannotInstantiateX % renderTree(n))
  558. result = n
  559. proc explicitGenericSym(c: PContext, n: PNode, s: PSym): PNode =
  560. # binding has to stay 'nil' for this to work!
  561. var m = newCandidate(c, s, nil)
  562. for i in 1..<n.len:
  563. let formal = s.ast[genericParamsPos][i-1].typ
  564. var arg = n[i].typ
  565. # try transforming the argument into a static one before feeding it into
  566. # typeRel
  567. if formal.kind == tyStatic and arg.kind != tyStatic:
  568. let evaluated = c.semTryConstExpr(c, n[i])
  569. if evaluated != nil:
  570. arg = newTypeS(tyStatic, c)
  571. arg.sons = @[evaluated.typ]
  572. arg.n = evaluated
  573. let tm = typeRel(m, formal, arg)
  574. if tm in {isNone, isConvertible}: return nil
  575. var newInst = generateInstance(c, s, m.bindings, n.info)
  576. newInst.typ.flags.excl tfUnresolved
  577. let info = getCallLineInfo(n)
  578. markUsed(c, info, s)
  579. onUse(info, s)
  580. result = newSymNode(newInst, info)
  581. proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym): PNode =
  582. assert n.kind == nkBracketExpr
  583. for i in 1..<n.len:
  584. let e = semExprWithType(c, n[i])
  585. if e.typ == nil:
  586. n[i].typ = errorType(c)
  587. else:
  588. n[i].typ = e.typ.skipTypes({tyTypeDesc})
  589. var s = s
  590. var a = n[0]
  591. if a.kind == nkSym:
  592. # common case; check the only candidate has the right
  593. # number of generic type parameters:
  594. if s.ast[genericParamsPos].safeLen != n.len-1:
  595. let expected = s.ast[genericParamsPos].safeLen
  596. localError(c.config, getCallLineInfo(n), errGenerated, "cannot instantiate: '" & renderTree(n) &
  597. "'; got " & $(n.len-1) & " typeof(s) but expected " & $expected)
  598. return n
  599. result = explicitGenericSym(c, n, s)
  600. if result == nil: result = explicitGenericInstError(c, n)
  601. elif a.kind in {nkClosedSymChoice, nkOpenSymChoice}:
  602. # choose the generic proc with the proper number of type parameters.
  603. # XXX I think this could be improved by reusing sigmatch.paramTypesMatch.
  604. # It's good enough for now.
  605. result = newNodeI(a.kind, getCallLineInfo(n))
  606. for i in 0..<a.len:
  607. var candidate = a[i].sym
  608. if candidate.kind in {skProc, skMethod, skConverter,
  609. skFunc, skIterator}:
  610. # it suffices that the candidate has the proper number of generic
  611. # type parameters:
  612. if candidate.ast[genericParamsPos].safeLen == n.len-1:
  613. let x = explicitGenericSym(c, n, candidate)
  614. if x != nil: result.add(x)
  615. # get rid of nkClosedSymChoice if not ambiguous:
  616. if result.len == 1 and a.kind == nkClosedSymChoice:
  617. result = result[0]
  618. elif result.len == 0: result = explicitGenericInstError(c, n)
  619. # candidateCount != 1: return explicitGenericInstError(c, n)
  620. else:
  621. result = explicitGenericInstError(c, n)
  622. proc searchForBorrowProc(c: PContext, startScope: PScope, fn: PSym): PSym =
  623. # Searches for the fn in the symbol table. If the parameter lists are suitable
  624. # for borrowing the sym in the symbol table is returned, else nil.
  625. # New approach: generate fn(x, y, z) where x, y, z have the proper types
  626. # and use the overloading resolution mechanism:
  627. var call = newNodeI(nkCall, fn.info)
  628. var hasDistinct = false
  629. call.add(newIdentNode(fn.name, fn.info))
  630. for i in 1..<fn.typ.n.len:
  631. let param = fn.typ.n[i]
  632. const desiredTypes = abstractVar + {tyCompositeTypeClass} - {tyTypeDesc, tyDistinct}
  633. #[.
  634. # We only want the type not any modifiers such as `ptr`, `var`, `ref` ...
  635. # tyCompositeTypeClass is here for
  636. # when using something like:
  637. type Foo[T] = distinct int
  638. proc `$`(f: Foo): string {.borrow.}
  639. # We want to skip the `Foo` to get `int`
  640. ]#
  641. let t = skipTypes(param.typ, desiredTypes)
  642. if t.kind == tyDistinct or param.typ.kind == tyDistinct: hasDistinct = true
  643. var x: PType
  644. if param.typ.kind == tyVar:
  645. x = newTypeS(param.typ.kind, c)
  646. x.addSonSkipIntLit(t.baseOfDistinct(c.graph, c.idgen), c.idgen)
  647. else:
  648. x = t.baseOfDistinct(c.graph, c.idgen)
  649. call.add(newNodeIT(nkEmpty, fn.info, x))
  650. if hasDistinct:
  651. let filter = if fn.kind in {skProc, skFunc}: {skProc, skFunc} else: {fn.kind}
  652. var resolved = semOverloadedCall(c, call, call, filter, {})
  653. if resolved != nil:
  654. result = resolved[0].sym
  655. if not compareTypes(result.typ[0], fn.typ[0], dcEqIgnoreDistinct):
  656. result = nil
  657. elif result.magic in {mArrPut, mArrGet}:
  658. # cannot borrow these magics for now
  659. result = nil