From e7cb6420582886b02289922ea981a687e8846466 Mon Sep 17 00:00:00 2001 From: metagn <10591326+metagn@users.noreply.github.com> Date: Thu, 28 Dec 2023 01:22:17 +0300 Subject: [PATCH] attempt cleaning up helper proc --- compiler/lookups.nim | 37 ++++++++++++++++++++----------------- compiler/semexprs.nim | 37 ++++++++++++++++++------------------- 2 files changed, 38 insertions(+), 36 deletions(-) diff --git a/compiler/lookups.nim b/compiler/lookups.nim index 708b25388e23d..52296644dd10a 100644 --- a/compiler/lookups.nim +++ b/compiler/lookups.nim @@ -303,8 +303,16 @@ proc isAmbiguous*(c: PContext, s: PIdent, filter: TSymKinds, sym: var PSym): boo # imports had a candidate but wasn't ambiguous return false -proc errorSym*(c: PContext, n: PNode): PSym = +proc errorSym*(c: PContext, ident: PIdent, info: TLineInfo): PSym = ## creates an error symbol to avoid cascading errors (for IDE support) + result = newSym(skError, ident, c.idgen, getCurrOwner(c), info, {}) + result.typ = errorType(c) + incl(result.flags, sfDiscardable) + # pretend it's from the top level scope to prevent cascading errors: + if c.config.cmd != cmdInteractive and c.compilesContextId == 0: + c.moduleScope.addSym(result) + +proc errorSym*(c: PContext, n: PNode): PSym = var m = n # ensure that 'considerQuotedIdent' can't fail: if m.kind == nkDotExpr: m = m[1] @@ -312,12 +320,7 @@ proc errorSym*(c: PContext, n: PNode): PSym = considerQuotedIdent(c, m) else: getIdent(c.cache, "err:" & renderTree(m)) - result = newSym(skError, ident, c.idgen, getCurrOwner(c), n.info, {}) - result.typ = errorType(c) - incl(result.flags, sfDiscardable) - # pretend it's from the top level scope to prevent cascading errors: - if c.config.cmd != cmdInteractive and c.compilesContextId == 0: - c.moduleScope.addSym(result) + result = errorSym(c, ident, n.info) type TOverloadIterMode* = enum @@ -499,7 +502,7 @@ proc mustFixSpelling(c: PContext): bool {.inline.} = result = c.config.spellSuggestMax != 0 and c.compilesContextId == 0 # don't slowdown inside compiles() -proc fixSpelling(c: PContext, n: PNode, ident: PIdent, result: var string) = +proc fixSpelling(c: PContext, ident: PIdent, result: var string) = ## when we cannot find the identifier, suggest nearby spellings var list = initHeapQueue[SpellCandidate]() let name0 = ident.s.nimIdentNormalize @@ -589,11 +592,11 @@ proc errorUndeclaredIdentifier*(c: PContext; info: TLineInfo; name: string, extr c.recursiveDep = "" localError(c.config, info, errGenerated, err) -proc errorUndeclaredIdentifierHint*(c: PContext; n: PNode, ident: PIdent): PSym = +proc errorUndeclaredIdentifierHint*(c: PContext; ident: PIdent; info: TLineInfo): PSym = var extra = "" - if c.mustFixSpelling: fixSpelling(c, n, ident, extra) - errorUndeclaredIdentifier(c, n.info, ident.s, extra) - result = errorSym(c, n) + if c.mustFixSpelling: fixSpelling(c, ident, extra) + errorUndeclaredIdentifier(c, info, ident.s, extra) + result = errorSym(c, ident, info) proc lookUp*(c: PContext, n: PNode): PSym = # Looks up a symbol. Generates an error in case of nil. @@ -601,13 +604,13 @@ proc lookUp*(c: PContext, n: PNode): PSym = case n.kind of nkIdent: result = searchInScopes(c, n.ident, amb) - if result == nil: result = errorUndeclaredIdentifierHint(c, n, n.ident) + if result == nil: result = errorUndeclaredIdentifierHint(c, n.ident, n.info) of nkSym: result = n.sym of nkAccQuoted: var ident = considerQuotedIdent(c, n) result = searchInScopes(c, ident, amb) - if result == nil: result = errorUndeclaredIdentifierHint(c, n, ident) + if result == nil: result = errorUndeclaredIdentifierHint(c, ident, n.info) else: internalError(c.config, n.info, "lookUp") return nil @@ -652,7 +655,7 @@ proc qualifiedLookUp*(c: PContext, n: PNode, flags: set[TLookupFlag]): PSym = else: result = nil if result == nil and checkUndeclared in flags: - result = errorUndeclaredIdentifierHint(c, n, ident) + result = errorUndeclaredIdentifierHint(c, ident, n.info) elif checkAmbiguity in flags and result != nil and amb: result = errorUseQualifier(c, n.info, result, amb) c.isAmbiguous = amb @@ -677,12 +680,12 @@ proc qualifiedLookUp*(c: PContext, n: PNode, flags: set[TLookupFlag]): PSym = else: result = someSym(c.graph, m, ident) if result == nil and checkUndeclared in flags: - result = errorUndeclaredIdentifierHint(c, n[1], ident) + result = errorUndeclaredIdentifierHint(c, ident, n[1].info) elif n[1].kind == nkSym: result = n[1].sym if result.owner != nil and result.owner != m and checkUndeclared in flags: # dotExpr in templates can end up here - result = errorUndeclaredIdentifierHint(c, n[1], considerQuotedIdent(c, n[1])) + result = errorUndeclaredIdentifierHint(c, result.name, n[1].info) elif checkUndeclared in flags and n[1].kind notin {nkOpenSymChoice, nkClosedSymChoice}: localError(c.config, n[1].info, "identifier expected, but got: " & diff --git a/compiler/semexprs.nim b/compiler/semexprs.nim index 3f98042783e90..416d4a472c7f3 100644 --- a/compiler/semexprs.nim +++ b/compiler/semexprs.nim @@ -2998,52 +2998,53 @@ proc semPragmaStmt(c: PContext; n: PNode) = else: pragma(c, c.p.owner, n, stmtPragmas, true) -proc resolveIdent(c: PContext, ident: PIdent, s: var PSym, n: PNode, - flags: TExprFlags, expectedType: PType): PNode = - result = nil +proc resolveIdent(c: PContext, ident: PIdent, resultNode: var PNode, + info: TLineInfo, flags: TExprFlags, expectedType: PType): PSym = + # result is nil if error or a node that can't produce a sym is resolved if expectedType != nil and ( let expected = expectedType.skipTypes(abstractRange-{tyDistinct}); expected.kind == tyEnum): let nameId = ident.id for f in expected.n: if f.kind == nkSym and f.sym.name.id == nameId: - s = f.sym - return + return f.sym var filter = {low(TSymKind)..high(TSymKind)} if efNoEvaluateGeneric in flags: # `a[...]` where `a` is a module or package is not possible filter.excl {skModule, skPackage} let candidates = lookUpCandidates(c, ident, filter) if candidates.len == 0: - s = errorUndeclaredIdentifierHint(c, n, ident) + result = errorUndeclaredIdentifierHint(c, ident, info) elif candidates.len == 1 or {efNoEvaluateGeneric, efInCall} * flags != {}: # unambiguous, or we don't care about ambiguity - s = candidates[0] + result = candidates[0] else: # ambiguous symbols have 1 last chance as a symchoice, # but type symbols cannot participate in symchoices - var choice = newNodeIT(nkClosedSymChoice, n.info, newTypeS(tyNone, c)) + var choice = newNodeIT(nkClosedSymChoice, info, newTypeS(tyNone, c)) for c in candidates: if c.kind notin {skType, skModule, skPackage}: - choice.add newSymNode(c, n.info) + choice.add newSymNode(c, info) if choice.len == 0: # we know candidates.len > 1, we just couldn't put any in a symchoice - errorUseQualifier(c, n.info, candidates) - return + errorUseQualifier(c, info, candidates) + return nil resolveSymChoice(c, choice, flags, expectedType) # choice.len == 1 can be true here but as long as it's a symchoice # it's still not resolved if isSymChoice(choice): if efAllowSymChoice in flags: - result = choice + resultNode = choice + result = nil else: - errorUseQualifier(c, n.info, candidates) + errorUseQualifier(c, info, candidates) else: if choice.kind == nkSym: - s = choice.sym + result = choice.sym else: # resolution could have generated nkHiddenStdConv etc - result = semExpr(c, choice, flags, expectedType) + resultNode = semExpr(c, choice, flags, expectedType) + result = nil proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType = nil): PNode = when defined(nimCompilerStacktraceHints): @@ -3083,11 +3084,9 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType case n.kind of nkIdent, nkAccQuoted: let ident = considerQuotedIdent(c, n) - var s: PSym = nil - let resolvedNode = resolveIdent(c, ident, s, n, flags, expectedType) - if resolvedNode != nil: - result = resolvedNode + let s = resolveIdent(c, ident, result, n.info, flags, expectedType) if s == nil: + # resolveIdent either errored or gave a result node return if c.matchedConcept == nil: semCaptureSym(s, c.p.owner) case s.kind