semdata

Source Edit

This module contains the data structures for the semantic checking phase.

Imports

options, ast, astalgo, msgs, idents, renderer, magicsys, vmdef, modulegraphs, lineinfos, pathutils, ic/ic

Types

ImportedModule = object
  m*: PSym
  case mode*: ImportMode
  of importAll:
    nil
  of importSet:
    imported*: IntSet
  of importExcept:
    exceptSet*: IntSet

Source Edit

ImportMode = enum
  importAll, importSet, importExcept

Source Edit

PContext = ref TContext

Source Edit

POptionEntry = ref TOptionEntry

Source Edit

PProcCon = ref TProcCon

Source Edit

TBorrowState = enum
  bsNone, bsReturnNotMatch, bsNoDistinct, bsGeneric, bsNotSupported, bsMatch

Source Edit

TContext = object of TPassContext
  enforceVoidContext*: PType
  voidType*: PType
  module*: PSym
  currentScope*: PScope
  moduleScope*: PScope
  imports*: seq[ImportedModule]
  topLevelScope*: PScope
  p*: PProcCon
  intTypeCache*: array[-5 .. 32, PType]
  nilTypeCache*: PType
  matchedConcept*: ptr TMatchedConcept
  friendModules*: seq[PSym]
  instCounter*: int
  templInstCounter*: ref int
  inGenericContext*: int
  inStaticContext*: int
  inUnrolledContext*: int
  compilesContextId*: int
  compilesContextIdGenerator*: int
  inGenericInst*: int
  converters*: seq[PSym]
  patterns*: seq[PSym]
  optionStack*: seq[POptionEntry]
  libs*: seq[PLib]
  semConstExpr*: proc (c: PContext; n: PNode; expectedType: PType = nil): PNode {.
      nimcall.}
  semExpr*: proc (c: PContext; n: PNode; flags: TExprFlags = {};
                  expectedType: PType = nil): PNode {.nimcall.}
  semExprWithType*: proc (c: PContext; n: PNode; flags: TExprFlags = {};
                          expectedType: PType = nil): PNode {.nimcall.}
  semTryExpr*: proc (c: PContext; n: PNode; flags: TExprFlags = {}): PNode {.
      nimcall.}
  semTryConstExpr*: proc (c: PContext; n: PNode; expectedType: PType = nil): PNode {.
      nimcall.}
  computeRequiresInit*: proc (c: PContext; t: PType): bool {.nimcall.}
  hasUnresolvedArgs*: proc (c: PContext; n: PNode): bool
  semOperand*: proc (c: PContext; n: PNode; flags: TExprFlags = {}): PNode {.
      nimcall.}
  semConstBoolExpr*: proc (c: PContext; n: PNode): PNode {.nimcall.}
  semOverloadedCall*: proc (c: PContext; n, nOrig: PNode; filter: TSymKinds;
                            flags: TExprFlags; expectedType: PType = nil): PNode {.
      nimcall.}
  semTypeNode*: proc (c: PContext; n: PNode; prev: PType): PType {.nimcall.}
  semInferredLambda*: proc (c: PContext; pt: Table[ItemId, PType]; n: PNode): PNode
  semGenerateInstance*: proc (c: PContext; fn: PSym; pt: Table[ItemId, PType];
                              info: TLineInfo): PSym
  instantiateOnlyProcType*: proc (c: PContext; pt: TypeMapping; prc: PSym;
                                  info: TLineInfo): PType
  includedFiles*: IntSet
  pureEnumFields*: TStrTable
  userPragmas*: TStrTable
  evalContext*: PEvalContext
  unknownIdents*: IntSet
  generics*: seq[TInstantiationPair]
  topStmts*: int
  lastGenericIdx*: int
  hloLoopDetector*: int
  inParallelStmt*: int
  instTypeBoundOp*: proc (c: PContext; dc: PSym; t: PType; info: TLineInfo;
                          op: TTypeAttachedOp; col: int): PSym {.nimcall.}
  cache*: IdentCache
  graph*: ModuleGraph
  signatures*: TStrTable
  recursiveDep*: string
  suggestionsMade*: bool
  isAmbiguous*: bool
  features*: set[Feature]
  inTypeContext*, inConceptDecl*: int
  unusedImports*: seq[(PSym, TLineInfo)]
  exportIndirections*: HashSet[(int, int)]
  importModuleMap*: Table[int, int]
  lastTLineInfo*: TLineInfo
  sideEffects*: Table[int, seq[(TLineInfo, PSym)]]
  inUncheckedAssignSection*: int
  importModuleLookup*: Table[int, seq[int]]
  skipTypes*: seq[PNode]
  inTypeofContext*: int

Source Edit

TExprFlag = enum
  efLValue, efWantIterator, efWantIterable, efInTypeof, efNeedStatic,
  efPreferStatic, efPreferNilResult, efWantStmt, efAllowStmt, efDetermineType,
  efExplain, efWantValue, efOperand, efNoSemCheck, efNoEvaluateGeneric,
  efInCall, efFromHlo, efNoSem2Check, efNoUndeclared, efIsDotCall,
  efCannotBeDotCall, efTypeAllowed, efWantNoDefaults, efIgnoreDefaults,
  efAllowSymChoice

Source Edit

TExprFlags = set[TExprFlag]

Source Edit

TInstantiationPair = object
  genericSym*: PSym
  inst*: PInstantiation

Source Edit

TMatchedConcept = object
  candidateType*: PType
  prev*: ptr TMatchedConcept
  depth*: int

Source Edit

TOptionEntry = object
  options*: TOptions
  defaultCC*: TCallingConvention
  dynlib*: PLib
  notes*: TNoteKinds
  features*: set[Feature]
  otherPragmas*: PNode
  warningAsErrors*: TNoteKinds

Source Edit

TProcCon {.acyclic.} = object
  owner*: PSym
  resultSym*: PSym
  nestedLoopCounter*: int
  nestedBlockCounter*: int
  breakInLoop*: bool
  next*: PProcCon
  mappingExists*: bool
  mapping*: Table[ItemId, PSym]
  caseContext*: seq[tuple[n: PNode, idx: int]]
  localBindStmts*: seq[PNode]

Source Edit

Procs

proc addConverter(c: PContext; conv: LazySym) {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc addConverterDef(c: PContext; conv: LazySym) {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc addImportFileDep(c: PContext; f: FileIndex) {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc addIncludeFileDep(c: PContext; f: FileIndex) {....raises: [IOError],
    tags: [ReadIOEffect], forbids: [].}

Source Edit

proc addPattern(c: PContext; p: LazySym) {....raises: [], tags: [], forbids: [].}

Source Edit

proc addPragmaComputation(c: PContext; n: PNode) {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc addPureEnum(c: PContext; e: LazySym) {....raises: [], tags: [], forbids: [].}

Source Edit

proc addToGenericCache(c: PContext; s: PSym; inst: PType) {....raises: [],
    tags: [], forbids: [].}

Source Edit

proc addToGenericProcCache(c: PContext; s: PSym; inst: PInstantiation) {.
    ...raises: [], tags: [], forbids: [].}

Source Edit

proc addToLib(lib: PLib; sym: PSym) {....raises: [], tags: [], forbids: [].}

Source Edit

proc checkMinSonsLen(n: PNode; length: int; conf: ConfigRef) {....raises: [
    Exception, ValueError, KeyError, OSError, IOError, ERecoverableError], tags: [
    RootEffect, ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect],
    forbids: [].}

Source Edit

proc checkSonsLen(n: PNode; length: int; conf: ConfigRef) {....raises: [Exception,
    ValueError, KeyError, OSError, IOError, ERecoverableError], tags: [
    RootEffect, ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect],
    forbids: [].}

Source Edit

proc considerGenSyms(c: PContext; n: PNode) {....raises: [], tags: [], forbids: [].}

Source Edit

proc errorNode(c: PContext; n: PNode): PNode {....raises: [], tags: [], forbids: [].}

Source Edit

proc errorType(c: PContext): PType {....raises: [], tags: [], forbids: [].}

creates a type representing an error state Source Edit

proc exportSym(c: PContext; s: PSym) {....raises: [], tags: [], forbids: [].}

Source Edit

proc filename(c: PContext): string {....raises: [], tags: [], forbids: [].}

Source Edit

proc fillTypeS(dest: PType; kind: TTypeKind; c: PContext) {....raises: [],
    tags: [], forbids: [].}

Source Edit

proc get(p: PProcCon; key: PSym): PSym {....raises: [], tags: [], forbids: [].}

Source Edit

proc getCurrOwner(c: PContext): PSym {....raises: [], tags: [], forbids: [].}

Source Edit

proc getGenSym(c: PContext; s: PSym): PSym {....raises: [], tags: [], forbids: [].}

Source Edit

proc getIntLitType(c: PContext; literal: PNode): PType {....raises: [KeyError,
    Exception, ValueError, OSError, IOError, ERecoverableError], tags: [
    ReadDirEffect, RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect],
    forbids: [].}

Source Edit

proc illFormedAst(n: PNode; conf: ConfigRef) {....raises: [Exception, ValueError,
    KeyError, OSError, IOError, ERecoverableError], tags: [RootEffect,
    ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect], forbids: [].}

Source Edit

proc illFormedAstLocal(n: PNode; conf: ConfigRef) {....raises: [Exception,
    ValueError, KeyError, OSError, IOError, ERecoverableError], tags: [
    RootEffect, ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect],
    forbids: [].}

Source Edit

proc isSelf(t: PType): bool {.inline, ...raises: [], tags: [], forbids: [].}

Is this the magical 'Self' type from concepts? Source Edit

proc isTopLevel(c: PContext): bool {.inline, ...raises: [], tags: [], forbids: [].}

Source Edit

proc isTopLevelInsideDeclaration(c: PContext; sym: PSym): bool {.inline,
    ...raises: [], tags: [], forbids: [].}

Source Edit

proc lastOptionEntry(c: PContext): POptionEntry {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc makeAndType(c: PContext; t1, t2: PType): PType {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc makeInstPair(s: PSym; inst: PInstantiation): TInstantiationPair {.
    ...raises: [], tags: [], forbids: [].}

Source Edit

proc makeNotType(c: PContext; t1: PType): PType {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc makeOrType(c: PContext; t1, t2: PType): PType {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc makePtrType(c: PContext; baseType: PType): PType {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc makePtrType(owner: PSym; baseType: PType; idgen: IdGenerator): PType {.
    ...raises: [], tags: [], forbids: [].}

Source Edit

proc makeRangeType(c: PContext; first, last: BiggestInt; info: TLineInfo;
                   intType: PType = nil): PType {....raises: [KeyError, Exception,
    ValueError, OSError, IOError, ERecoverableError], tags: [ReadDirEffect,
    RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect], forbids: [].}

Source Edit

proc makeRangeWithStaticExpr(c: PContext; n: PNode): PType {....raises: [KeyError,
    Exception, ValueError, OSError, IOError, ERecoverableError], tags: [
    ReadDirEffect, RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect],
    forbids: [].}

Source Edit

proc makeStaticExpr(c: PContext; n: PNode): PNode {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc makeTypeDesc(c: PContext; typ: PType): PType {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc makeTypeFromExpr(c: PContext; n: PNode): PType {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc makeTypeSymNode(c: PContext; typ: PType; info: TLineInfo): PNode {....raises: [
    Exception, ValueError, KeyError, OSError, IOError, ERecoverableError], tags: [
    RootEffect, ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect],
    forbids: [].}

Source Edit

proc makeTypeWithModifier(c: PContext; modifier: TTypeKind; baseType: PType): PType {.
    ...raises: [], tags: [], forbids: [].}

Source Edit

proc makeVarType(c: PContext; baseType: PType; kind = tyVar): PType {.
    ...raises: [], tags: [], forbids: [].}

Source Edit

proc markIndirect(c: PContext; s: PSym) {.inline, ...raises: [], tags: [],
    forbids: [].}

Source Edit

proc newContext(graph: ModuleGraph; module: PSym): PContext {....raises: [IOError],
    tags: [ReadIOEffect], forbids: [].}

Source Edit

proc newLib(kind: TLibKind): PLib {....raises: [], tags: [], forbids: [].}

Source Edit

proc newOptionEntry(conf: ConfigRef): POptionEntry {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc newTypeS(kind: TTypeKind; c: PContext; son: sink PType = nil): PType {.
    ...raises: [], tags: [], forbids: [].}

Source Edit

proc popCaseContext(c: PContext) {....raises: [], tags: [], forbids: [].}

Source Edit

proc popOptionEntry(c: PContext) {....raises: [], tags: [], forbids: [].}

Source Edit

proc popOwner(c: PContext) {....raises: [Exception, ValueError, KeyError, OSError,
                                      IOError, ERecoverableError], tags: [
    RootEffect, ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect],
                             forbids: [].}

Source Edit

proc popProcCon(c: PContext) {.inline, ...raises: [], tags: [], forbids: [].}

Source Edit

proc pushCaseContext(c: PContext; caseNode: PNode) {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc pushOptionEntry(c: PContext): POptionEntry {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc pushOwner(c: PContext; owner: PSym) {....raises: [], tags: [], forbids: [].}

Source Edit

proc put(p: PProcCon; key, val: PSym) {....raises: [], tags: [], forbids: [].}

Source Edit

proc reexportSym(c: PContext; s: PSym) {....raises: [], tags: [], forbids: [].}

Source Edit

proc rememberExpansion(c: PContext; info: TLineInfo; expandedSym: PSym) {.
    ...raises: [], tags: [], forbids: [].}

Templates and macros are very special in Nim; these have inlining semantics so after semantic checking they leave no trace in the sem'checked AST. This is very bad for IDE-like tooling ("find all usages of this template" would not work). We need special logic to remember macro/template expansions. This is done here and delegated to the "rod" file mechanism. Source Edit

proc scopeDepth(c: PContext): int {.inline, ...raises: [], tags: [], forbids: [].}

Source Edit

proc sealRodFile(c: PContext) {....raises: [], tags: [], forbids: [].}

Source Edit

proc setCaseContextIdx(c: PContext; idx: int) {....raises: [], tags: [],
    forbids: [].}

Source Edit

proc setIntLitType(c: PContext; result: PNode) {....raises: [KeyError, Exception,
    ValueError, OSError, IOError, ERecoverableError], tags: [ReadDirEffect,
    RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect], forbids: [].}

Source Edit

proc storeRodNode(c: PContext; n: PNode) {....raises: [Exception],
    tags: [RootEffect], forbids: [].}

Source Edit

proc symFromType(c: PContext; t: PType; info: TLineInfo): PSym {....raises: [],
    tags: [], forbids: [].}

Source Edit

proc symNodeFromType(c: PContext; t: PType; info: TLineInfo): PNode {.
    ...raises: [], tags: [], forbids: [].}

Source Edit

Templates

template addExport(c: PContext; s: PSym)

convenience to export a symbol from the current module Source Edit

template config(c: PContext): ConfigRef

Source Edit

template encoder(c): untyped

Source Edit

template localErrorNode(c: PContext; n: PNode; arg: string): PNode

Source Edit

template localErrorNode(c: PContext; n: PNode; info: TLineInfo; arg: string): PNode

Source Edit

template localErrorNode(c: PContext; n: PNode; info: TLineInfo; msg: TMsgKind;
                        arg: string): PNode

Source Edit

template localErrorNode(c: PContext; n: PNode; msg: TMsgKind; arg: string): PNode

Source Edit

template packedRepr(c): untyped

Source Edit

template rangeHasUnresolvedStatic(t: PType): bool

Source Edit