attempt cleaning up helper proc

compiler/lookups.nim

@@ -303,21 +303,24 @@ 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]
   let ident = if m.kind in {nkIdent, nkSym, nkAccQuoted}:
       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,25 +592,25 @@ 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.
   var amb = false
   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: " &

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