diff --git a/compiler/lookups.nim b/compiler/lookups.nim index 308551741753..02a8ab9852d9 100644 --- a/compiler/lookups.nim +++ b/compiler/lookups.nim @@ -313,7 +313,6 @@ proc qualifiedLookUp*(c: PContext, n: PNode, flags: set[TLookupFlag]): PSym = result = searchInScopes(c, ident, allExceptModule).skipAlias(n, c.config) if result == nil and checkPureEnumFields in flags: result = strTableGet(c.pureEnumFields, ident) - # if result == nil and checkUndeclared in flags: if result == nil and checkUndeclared in flags and checkOverloadResolve notin flags: fixSpelling(n, ident, searchInScopes) errorUndeclaredIdentifier(c, n.info, ident.s) diff --git a/compiler/semcall.nim b/compiler/semcall.nim index 3714372c13f1..8e33b83c1450 100644 --- a/compiler/semcall.nim +++ b/compiler/semcall.nim @@ -384,8 +384,7 @@ proc resolveOverloads(c: PContext, n, orig: PNode, pickBest(callOp) if overloadsState == csEmpty and result.state == csEmpty: - if {efNoUndeclared, efOverloadResolve} * flags == {}: - # for tests/pragmas/tcustom_pragma.nim + if {efNoUndeclared, efOverloadResolve} * flags == {}: # for tests/pragmas/tcustom_pragma.nim localError(c.config, n.info, getMsgDiagnostic(c, flags, n, f)) return elif result.state != csMatch: diff --git a/compiler/semdata.nim b/compiler/semdata.nim index f5d73b71870e..380c99de3d91 100644 --- a/compiler/semdata.nim +++ b/compiler/semdata.nim @@ -68,8 +68,7 @@ type # Use this if undeclared identifiers should not raise an error during # overload resolution. efOverloadResolve, - # for `mOverloadResolve` evaluation - # return resolved `foo` in `foo(args)` + # for `mOverloadResolve` evaluation, resolves `foo` in `foo(args)` TExprFlags* = set[TExprFlag] diff --git a/compiler/semexprs.nim b/compiler/semexprs.nim index 2ef5525d94a6..5ed57edc64d7 100644 --- a/compiler/semexprs.nim +++ b/compiler/semexprs.nim @@ -10,8 +10,6 @@ # this module does the semantic checking for expressions # included from sem.nim -import std/wrapnils - const errExprXHasNoType = "expression '$1' has no type (or is ambiguous)" errXExpectsTypeOrValue = "'$1' expects a type or value" @@ -62,11 +60,8 @@ proc semOperand(c: PContext, n: PNode, flags: TExprFlags = {}): PNode = result.typ = errorType(c) proc semExprWithType(c: PContext, n: PNode, flags: TExprFlags = {}): PNode = - echo0b (flags, c.config$n.info) rejectEmptyNode(n) - echo0b () result = semExpr(c, n, flags+{efWantValue}) - echo0b () if result == nil: return errorNode(c, n) if result.kind == nkEmpty: # do not produce another redundant error message: @@ -913,20 +908,8 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags): PNode = else: n[0] = n0 else: - echo0b (flags, n[0].renderTree, n.renderTree, n.kind, n[0].kind) - var flags2 = {efInCall} - if efOverloadResolve in flags and efOperand notin flags: flags2.incl efOverloadResolve - n[0] = semExpr(c, n[0], flags2) - # n[0] = semExpr(c, n[0], {efInCall} + flags * {efOverloadResolve}) - # n[0] = semExpr(c, n[0], {efInCall}) - if efOverloadResolve in flags: - echo0b (flags, n[0] == nil, ) - if n[0] != nil: - echo0b n[0].kind - if n[0] == nil and efOverloadResolve in flags: - echo0b "errorNode" - return errorNode(c, n) - # return nil + n[0] = semExpr(c, n[0], {efInCall} + flags * {efOverloadResolve}) + if n[0] == nil and efOverloadResolve in flags: return errorNode(c, n) let t = n[0].typ if t != nil and t.kind in {tyVar, tyLent}: n[0] = newDeref(n[0]) @@ -1292,9 +1275,7 @@ proc builtinFieldAccess(c: PContext, n: PNode, flags: TExprFlags): PNode = if exactEquals(c.config.m.trackPos, n[1].info): suggestExprNoCheck(c, n) var flags2 = {checkAmbiguity, checkUndeclared, checkModule} - if efOverloadResolve in flags: - flags2.incl checkOverloadResolve - # flags2.excl checkUndeclared # PRTEMP + if efOverloadResolve in flags: flags2.incl checkOverloadResolve var s = qualifiedLookUp(c, n, flags2) if efOverloadResolve in flags and n.kind == nkDotExpr: var m = qualifiedLookUp(c, n[0], (flags2*{checkUndeclared})+{checkModule}) @@ -2134,37 +2115,20 @@ proc semCompiles(c: PContext, n: PNode, flags: TExprFlags): PNode = proc semOverloadResolve(c: PContext, n: PNode, flags: TExprFlags, isTopLevel: bool): PNode = var n = n - echo0b (c.config$n.info, n.kind, flags, isTopLevel) if isTopLevel: if n.len != 2: localError(c.config, n.info, "semOverloadResolve: got" & $n.len) return n = n[1] - let nKind = n.kind if n.kind notin {nkIdent,nkDotExpr,nkAccQuoted} + nkCallKinds - {nkHiddenCallConv}: localError(c.config, n.info, "expected routine, got " & $n.kind) - return - - # PRTEMP: remove efOperand stuff - # let flags = flags + {efWantIterator, efOverloadResolve} + return errorNode(c, n) if n.kind == nkDotExpr: - # let flags = flags + {efWantIterator, efOverloadResolve} - {efOperand} - # result = semExpr(c, n[0], flags) - # result = semExpr(c, n[0], flags) + # so that this doesn't compile: `overloadExists(nonexistant().foo)` n[0] = semExpr(c, n[0], flags) - let flags = flags + {efWantIterator, efOverloadResolve} - {efOperand} + let flags = flags + {efWantIterator, efOverloadResolve} result = semExpr(c, n, flags) - - echo0b (result == nil, ?.result.kind, nKind, flags) - # if result != nil and result.kind == nkEmpty and nKind == nkDotExpr: - when false: - if (result == nil or result.kind == nkEmpty) and nKind == nkDotExpr: - # localError() - # localError(c.config, n.info, "invalid expression for OverloadResolve: " & $n.renderTree) - localError(c.config, n.info, "invalid expression for OverloadResolve") - return result # PRTEMP if result == nil or result.kind == nkEmpty: - # doAssert isTopLevel # PRTEMP if isTopLevel: result = newNodeIT(nkNilLit, n.info, getSysType(c.graph, n.info, tyNil)) elif result.kind == nkClosedSymChoice: @@ -2642,12 +2606,7 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode = {checkUndeclared, checkModule, checkPureEnumFields} else: {checkUndeclared, checkModule, checkAmbiguity, checkPureEnumFields} - # if efOverloadResolve in flags and efInCall notin flags: - if efOverloadResolve in flags and efInCall in flags: - # PRTEMP efOverloadResolve checkOverloadResolve - # checks.excl checkUndeclared - checks.incl checkOverloadResolve - echo0b (checks, flags) + if efOverloadResolve in flags: checks.incl checkOverloadResolve var s = qualifiedLookUp(c, n, checks) if efOverloadResolve in flags and s == nil: return nil if c.matchedConcept == nil: semCaptureSym(s, c.p.owner) diff --git a/tests/magics/mresolves.nim b/tests/magics/mresolves.nim index 47910642dc1c..38c98a317408 100644 --- a/tests/magics/mresolves.nim +++ b/tests/magics/mresolves.nim @@ -1,6 +1,6 @@ import std/macros -macro overloadExistsImpl(x: typed): bool = +macro overloadExistsImpl(x: typed): bool = newLit(x != nil) template overloadExists*(a: untyped): bool = diff --git a/tests/magics/tresolve_overloads.nim b/tests/magics/tresolve_overloads.nim index 364643ee25ee..2658e95c896c 100644 --- a/tests/magics/tresolve_overloads.nim +++ b/tests/magics/tresolve_overloads.nim @@ -122,12 +122,23 @@ proc main()= doAssert not compiles(nonexistant.bar1) doAssert not compiles overloadExists(nonexistant.bar1) doAssert not compiles overloadExists(nonexistant().mfoo1) - doAssert not compiles overloadExists(nonexistant1().nonexistant2) doAssert not compiles overloadExists(nonexistant().bar2) doAssert not compiles overloadExists(nonexistant().bar1) - # doAssert not overloadExists(nonexistant) # PRTEMP + doAssert declared(mresolve_overloads) + doAssert declared(fun7) + doAssert declared(foo) + doAssert declared(`bar5`) + doAssert declared(bar5) + doAssert declared(`system`) + doAssert not declared(nonexistant) + doAssert not overloadExists(nonexistant) + doAssert not overloadExists(`nonexistant`) + doAssert overloadExists(system) + doAssert overloadExists(`system`) + doAssert overloadExists(`bar5`) + doAssert overloadExists(bar5) block: # resolveSymbol doAssert resolveSymbol(fun8(1))(3) == fun8(3) @@ -196,7 +207,7 @@ proc main2()= doAssert compiles resolveSymbol(system.compiles) inspect resolveSymbol(system.compiles) doAssert resolveSymbol(system.nonexistant) == nil - # doAssert resolveSymbol(nonexistant) == nil + doAssert resolveSymbol(nonexistant) == nil block: template bar1(): untyped = 12