From e1630dcc73f13023205d45cab7bcabc415766b66 Mon Sep 17 00:00:00 2001 From: Araq Date: Sun, 23 Nov 2014 01:45:53 +0100 Subject: [PATCH] fixes #1337 --- compiler/semgnrc.nim | 35 +++++++++------ tests/concurrency/tnodeadlocks.nim | 70 ------------------------------ tests/template/tit.nim | 11 +++++ 3 files changed, 33 insertions(+), 83 deletions(-) delete mode 100644 tests/concurrency/tnodeadlocks.nim create mode 100644 tests/template/tit.nim diff --git a/compiler/semgnrc.nim b/compiler/semgnrc.nim index 07e7a51361..0fa16497cf 100644 --- a/compiler/semgnrc.nim +++ b/compiler/semgnrc.nim @@ -13,7 +13,7 @@ # A problem is that it cannot be detected if the symbol is introduced # as in ``var x = ...`` or used because macros/templates can hide this! # So we have to eval templates/macros right here so that symbol -# lookup can be accurate. XXX But this can only be done for immediate macros! +# lookup can be accurate. # included from sem.nim @@ -99,7 +99,7 @@ proc newDot(n, b: PNode): PNode = result.add(b) proc fuzzyLookup(c: PContext, n: PNode, flags: TSemGenericFlags, - ctx: var IntSet): PNode = + ctx: var IntSet; isMacro: var bool): PNode = assert n.kind == nkDotExpr let luf = if withinMixin notin flags: {checkUndeclared} else: {} @@ -113,6 +113,7 @@ proc fuzzyLookup(c: PContext, n: PNode, flags: TSemGenericFlags, let ident = considerQuotedIdent(n) var s = searchInScopes(c, ident).skipAlias(n) if s != nil and s.kind in routineKinds: + isMacro = s.kind in {skTemplate, skMacro} if withinBind in flags: result = newDot(result, symChoice(c, n, s, scClosed)) elif s.name.id in ctx: @@ -141,7 +142,8 @@ proc semGenericStmt(c: PContext, n: PNode, #var s = qualifiedLookUp(c, n, luf) #if s != nil: result = semGenericStmtSymbol(c, n, s) # XXX for example: ``result.add`` -- ``add`` needs to be looked up here... - result = fuzzyLookup(c, n, flags, ctx) + var dummy: bool + result = fuzzyLookup(c, n, flags, ctx, dummy) of nkEmpty, nkSym..nkNilLit: # see tests/compile/tgensymgeneric.nim: # We need to open the gensym'ed symbol again so that the instantiation @@ -165,10 +167,10 @@ proc semGenericStmt(c: PContext, n: PNode, localError(n.info, errUndeclaredIdentifier, fn.renderTree) var first = 0 - var isDefinedMagic = false + var mixinContext = false if s != nil: incl(s.flags, sfUsed) - isDefinedMagic = s.magic in {mDefined, mDefinedInScope, mCompiles} + mixinContext = s.magic in {mDefined, mDefinedInScope, mCompiles} let scOption = if s.name.id in ctx: scForceOpen else: scOpen case s.kind of skMacro: @@ -177,8 +179,9 @@ proc semGenericStmt(c: PContext, n: PNode, result = semMacroExpr(c, n, n, s, {efNoSemCheck}) result = semGenericStmt(c, result, {}, ctx) else: - n.sons[0] = symChoice(c, n.sons[0], s, scOption) + n.sons[0] = symChoice(c, fn, s, scOption) result = n + mixinContext = true of skTemplate: if macroToExpand(s): styleCheckUse(fn.info, s) @@ -186,34 +189,40 @@ proc semGenericStmt(c: PContext, n: PNode, result = semTemplateExpr(c, n, s, {efNoSemCheck}) result = semGenericStmt(c, result, {}, ctx) else: - n.sons[0] = symChoice(c, n.sons[0], s, scOption) + n.sons[0] = symChoice(c, fn, s, scOption) result = n # BUGFIX: we must not return here, we need to do first phase of - # symbol lookup ... + # symbol lookup. Also since templates and macros can do scope injections + # we need to put the ``c`` in ``t(c)`` in a mixin context to prevent + # the famous "undeclared identifier: it" bug: + mixinContext = true of skUnknown, skParam: # Leave it as an identifier. discard of skProc, skMethod, skIterators, skConverter: - result.sons[0] = symChoice(c, n.sons[0], s, scOption) + result.sons[0] = symChoice(c, fn, s, scOption) first = 1 of skGenericParam: - result.sons[0] = newSymNodeTypeDesc(s, n.sons[0].info) + result.sons[0] = newSymNodeTypeDesc(s, fn.info) styleCheckUse(fn.info, s) first = 1 of skType: # bad hack for generics: if (s.typ != nil) and (s.typ.kind != tyGenericParam): - result.sons[0] = newSymNodeTypeDesc(s, n.sons[0].info) + result.sons[0] = newSymNodeTypeDesc(s, fn.info) styleCheckUse(fn.info, s) first = 1 else: - result.sons[0] = newSymNode(s, n.sons[0].info) + result.sons[0] = newSymNode(s, fn.info) styleCheckUse(fn.info, s) first = 1 + elif fn.kind == nkDotExpr: + result.sons[0] = fuzzyLookup(c, fn, flags, ctx, mixinContext) + first = 1 # Consider 'when defined(globalsSlot): ThreadVarSetValue(globalsSlot, ...)' # in threads.nim: the subtle preprocessing here binds 'globalsSlot' which # is not exported and yet the generic 'threadProcWrapper' works correctly. - let flags = if isDefinedMagic: flags+{withinMixin} else: flags + let flags = if mixinContext: flags+{withinMixin} else: flags for i in countup(first, sonsLen(result) - 1): result.sons[i] = semGenericStmt(c, result.sons[i], flags, ctx) of nkIfStmt: diff --git a/tests/concurrency/tnodeadlocks.nim b/tests/concurrency/tnodeadlocks.nim deleted file mode 100644 index 7a3eedbc22..0000000000 --- a/tests/concurrency/tnodeadlocks.nim +++ /dev/null @@ -1,70 +0,0 @@ -discard """ - outputsub: "101" - cmd: "nim $target --hints:on --threads:on $options $file" -""" - -import os, locks - -const - noDeadlocks = defined(preventDeadlocks) - -var - thr: array [0..5, TThread[tuple[a, b: int]]] - L, M, N: TLock - -proc doNothing() = discard - -proc threadFunc(interval: tuple[a, b: int]) {.thread.} = - doNothing() - for i in interval.a..interval.b: - when nodeadlocks: - case i mod 6 - of 0: - acquire(L) # lock stdout - acquire(M) - acquire(N) - of 1: - acquire(L) - acquire(N) # lock stdout - acquire(M) - of 2: - acquire(M) - acquire(L) - acquire(N) - of 3: - acquire(M) - acquire(N) - acquire(L) - of 4: - acquire(N) - acquire(M) - acquire(L) - of 5: - acquire(N) - acquire(L) - acquire(M) - else: assert false - else: - acquire(L) # lock stdout - acquire(M) - - echo i - os.sleep(10) - when nodeadlocks: - echo "deadlocks prevented: ", deadlocksPrevented - when nodeadlocks: - release(N) - release(M) - release(L) - -initLock(L) -initLock(M) -initLock(N) - -proc main = - for i in 0..high(thr): - createThread(thr[i], threadFunc, (i*100, i*100+50)) - joinThreads(thr) - -main() - diff --git a/tests/template/tit.nim b/tests/template/tit.nim new file mode 100644 index 0000000000..9866711de7 --- /dev/null +++ b/tests/template/tit.nim @@ -0,0 +1,11 @@ + +# bug #1337 + +template someIt(a, pred: expr): expr = + var it {.inject.} = 0 + pred + +proc aProc(n) = + n.someIt(echo(it)) + +aProc(89)