jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

remove ast.emptyNode global; cleanup configuration.nim

Browse source
This commit is contained in:
Araq 2018-05-16 03:06:07 +02:00
commit 2a7fc84c86
29 changed files with 148 additions and 312 deletions
Download patch file Download diff file Expand all files Collapse all files

10
compiler/ast.nim
View file

@ -1095,9 +1095,6 @@ proc newSym*(symKind: TSymKind, name: PIdent, owner: PSym,
# writeStacktrace() # writeStacktrace()
# MessageOut(name.s & " has id: " & toString(result.id)) # MessageOut(name.s & " has id: " & toString(result.id))
var emptyNode* = newNode(nkEmpty) # XXX global variable here!
# There is a single empty node that is shared! Do not overwrite it!
proc isMetaType*(t: PType): bool = proc isMetaType*(t: PType): bool =
return t.kind in tyMetaTypes or return t.kind in tyMetaTypes or
(t.kind == tyStatic and t.n == nil) or (t.kind == tyStatic and t.n == nil) or
@ -1229,13 +1226,10 @@ proc addSon*(father, son: PNode) =
if isNil(father.sons): father.sons = @[] if isNil(father.sons): father.sons = @[]
add(father.sons, son) add(father.sons, son)
var emptyParams = newNode(nkFormalParams)
emptyParams.addSon(emptyNode)
proc newProcNode*(kind: TNodeKind, info: TLineInfo, body: PNode, proc newProcNode*(kind: TNodeKind, info: TLineInfo, body: PNode,
params = emptyParams, params,
name, pattern, genericParams, name, pattern, genericParams,
pragmas, exceptions = ast.emptyNode): PNode = pragmas, exceptions: PNode): PNode =
result = newNodeI(kind, info) result = newNodeI(kind, info)
result.sons = @[name, pattern, genericParams, params, result.sons = @[name, pattern, genericParams, params,
pragmas, exceptions, body] pragmas, exceptions, body]

6
compiler/cgmeth.nim
View file

@ -115,7 +115,7 @@ proc createDispatcher(s: PSym): PSym =
# we can't inline the dispatcher itself (for now): # we can't inline the dispatcher itself (for now):
if disp.typ.callConv == ccInline: disp.typ.callConv = ccDefault if disp.typ.callConv == ccInline: disp.typ.callConv = ccDefault
disp.ast = copyTree(s.ast) disp.ast = copyTree(s.ast)
disp.ast.sons[bodyPos] = ast.emptyNode disp.ast.sons[bodyPos] = newNodeI(nkEmpty, s.info)
disp.loc.r = nil disp.loc.r = nil
if s.typ.sons[0] != nil: if s.typ.sons[0] != nil:
if disp.ast.sonsLen > resultPos: if disp.ast.sonsLen > resultPos:
@ -124,7 +124,7 @@ proc createDispatcher(s: PSym): PSym =
# We've encountered a method prototype without a filled-in # We've encountered a method prototype without a filled-in
# resultPos slot. We put a placeholder in there that will # resultPos slot. We put a placeholder in there that will
# be updated in fixupDispatcher(). # be updated in fixupDispatcher().
disp.ast.addSon(ast.emptyNode) disp.ast.addSon(newNodeI(nkEmpty, s.info))
attachDispatcher(s, newSymNode(disp)) attachDispatcher(s, newSymNode(disp))
# attach to itself to prevent bugs: # attach to itself to prevent bugs:
attachDispatcher(disp, newSymNode(disp)) attachDispatcher(disp, newSymNode(disp))
@ -137,7 +137,7 @@ proc fixupDispatcher(meth, disp: PSym; conf: ConfigRef) =
# the lock level of the dispatcher needs to be updated/checked # the lock level of the dispatcher needs to be updated/checked
# against that of the method. # against that of the method.
if disp.ast.sonsLen > resultPos and meth.ast.sonsLen > resultPos and if disp.ast.sonsLen > resultPos and meth.ast.sonsLen > resultPos and
disp.ast.sons[resultPos] == ast.emptyNode: disp.ast.sons[resultPos].kind == nkEmpty:
disp.ast.sons[resultPos] = copyTree(meth.ast.sons[resultPos]) disp.ast.sons[resultPos] = copyTree(meth.ast.sons[resultPos])
# The following code works only with lock levels, so we disable # The following code works only with lock levels, so we disable

178
compiler/configuration.nim
View file

@ -11,8 +11,6 @@
## needs to be passed around to everything so that the compiler becomes ## needs to be passed around to everything so that the compiler becomes
## more useful as a library. ## more useful as a library.
import tables
const const
explanationsBaseUrl* = "https://nim-lang.org/docs/manual" explanationsBaseUrl* = "https://nim-lang.org/docs/manual"
@ -182,179 +180,3 @@ const
const const
errXMustBeCompileTime* = "'$1' can only be used in compile-time context" errXMustBeCompileTime* = "'$1' can only be used in compile-time context"
errArgsNeedRunOption* = "arguments can only be given if the '--run' option is selected" errArgsNeedRunOption* = "arguments can only be given if the '--run' option is selected"
#[
errStringLiteralExpected: "string literal expected",
errIntLiteralExpected: "integer literal expected",
errIdentifierExpected: "identifier expected, but found '$1'",
errNewlineExpected: "newline expected, but found '$1'",
errInvalidModuleName: "invalid module name: '$1'",
errOnOrOffExpected: "'on' or 'off' expected",
errNoneSpeedOrSizeExpected: "'none', 'speed' or 'size' expected",
errInvalidPragma: "invalid pragma",
errUnknownPragma: "unknown pragma: '$1'",
errAtPopWithoutPush: "'pop' without a 'push' pragma",
errEmptyAsm: "empty asm statement",
errInvalidIndentation: "invalid indentation",
errNoReturnWithReturnTypeNotAllowed: "routines with NoReturn pragma are not allowed to have return type",
errAttemptToRedefine: ,
errStmtInvalidAfterReturn: "statement not allowed after 'return', 'break', 'raise', 'continue' or proc call with noreturn pragma",
errStmtExpected: "statement expected",
errInvalidLabel: "'$1' is no label",
errInvalidCmdLineOption: "invalid command line option: '$1'",
errCmdLineArgExpected: "argument for command line option expected: '$1'",
errCmdLineNoArgExpected: "invalid argument for command line option: '$1'",
errInvalidVarSubstitution: "invalid variable substitution in '$1'",
errUnknownVar: "unknown variable: '$1'",
errUnknownCcompiler: "unknown C compiler: '$1'",
errOnOrOffExpectedButXFound: "'on' or 'off' expected, but '$1' found",
errOnOffOrListExpectedButXFound: "'on', 'off' or 'list' expected, but '$1' found",
errGenOutExpectedButXFound: "'c', 'c++' or 'yaml' expected, but '$1' found",
,
errInvalidMultipleAsgn: "multiple assignment is not allowed",
errColonOrEqualsExpected: "':' or '=' expected, but found '$1'",
errUndeclaredField: "undeclared field: '$1'",
errUndeclaredRoutine: "attempting to call undeclared routine: '$1'",
errUseQualifier: "ambiguous identifier: '$1' -- use a qualifier",
errTypeExpected: "type expected",
errSystemNeeds: "system module needs '$1'",
errExecutionOfProgramFailed: "execution of an external program failed: '$1'",
errNotOverloadable: ,
errInvalidArgForX: "invalid argument for '$1'",
errStmtHasNoEffect: "statement has no effect",
,
errXExpectsArrayType: "'$1' expects an array type",
errIteratorCannotBeInstantiated: "'$1' cannot be instantiated because its body has not been compiled yet",
errExprXAmbiguous: "expression '$1' ambiguous in this context",
errConstantDivisionByZero: ,
errOrdinalOrFloatTypeExpected: "ordinal or float type expected",
errOverOrUnderflow: ,
errCannotEvalXBecauseIncompletelyDefined: ,
errChrExpectsRange0_255: "'chr' expects an int in the range 0..255",
errDynlibRequiresExportc: "'dynlib' requires 'exportc'",
errNilAccess: "attempt to access a nil address",
errIndexOutOfBounds: "index out of bounds",
errIndexTypesDoNotMatch: "index types do not match",
errBracketsInvalidForType: "'[]' operator invalid for this type",
errValueOutOfSetBounds: "value out of set bounds",
errFieldNotInit: "field '$1' not initialized",
errExprXCannotBeCalled: "expression '$1' cannot be called",
errExprHasNoType: "expression has no type",
errExprXHasNoType:,
errCastNotInSafeMode: "'cast' not allowed in safe mode",
errExprCannotBeCastToX: ,
errCommaOrParRiExpected: "',' or ')' expected",
errCurlyLeOrParLeExpected: "'{' or '(' expected",
errSectionExpected: "section ('type', 'proc', etc.) expected",
errRangeExpected: "range expected",
errMagicOnlyInSystem: "'magic' only allowed in system module",
errPowerOfTwoExpected: "power of two expected",
errStringMayNotBeEmpty: "string literal may not be empty",
errCallConvExpected: "calling convention expected",
errProcOnlyOneCallConv: "a proc can only have one calling convention",
errSymbolMustBeImported: "symbol must be imported if 'lib' pragma is used",
errExprMustBeBool: "expression must be of type 'bool'",
errConstExprExpected: "constant expression expected",
errDuplicateCaseLabel: "duplicate case label",
errRangeIsEmpty: "range is empty",
,
errSelectorMustBeOrdinal: "selector must be of an ordinal type",
errOrdXMustNotBeNegative: "ord($1) must not be negative",
errLenXinvalid: "len($1) must be less than 32768",
errTypeXhasUnknownSize: "type '$1' has unknown size",
errConstNeedsConstExpr: "a constant can only be initialized with a constant expression",
errConstNeedsValue: "a constant needs a value",
errResultCannotBeOpenArray: "the result type cannot be on open array",
errSizeTooBig: "computing the type's size produced an overflow",
errInheritanceOnlyWithEnums: "inheritance only works with an enum",
errIllegalRecursionInTypeX:,
errCannotInstantiateX: "cannot instantiate: '$1'",
errTypeMismatch: "type mismatch: got <",
errButExpected: "but expected one of: ",
errButExpectedX: "but expected '$1'",
errAmbiguousCallXYZ: "ambiguous call; both $1 and $2 match for: $3",
errWrongNumberOfArguments: "wrong number of arguments",
errWrongNumberOfArgumentsInCall: "wrong number of arguments in call to '$1'",
errMissingGenericParamsForTemplate: "'$1' has unspecified generic parameters",
errXCannotBePassedToProcVar: ,
,
errImplOfXexpected: ,
errIllegalConvFromXtoY: ,
errCannotBindXTwice: "cannot bind parameter '$1' twice",
errInvalidOrderInArrayConstructor: ,
errInvalidOrderInEnumX: "invalid order in enum '$1'",
errEnumXHasHoles: "enum '$1' has holes",
errExceptExpected: "'except' or 'finally' expected",
errInvalidTry: "after catch all 'except' or 'finally' no section may follow",
errOptionExpected: ,
errXisNoLabel: "'$1' is not a label",
errNotAllCasesCovered: "not all cases are covered",
errUnknownSubstitionVar: "unknown substitution variable: '$1'",
errComplexStmtRequiresInd: "complex statement requires indentation",
errXisNotCallable: "'$1' is not callable",
errNoPragmasAllowedForX: "no pragmas allowed for $1",
,
errInvalidParamKindX: "invalid param kind: '$1'",
errDefaultArgumentInvalid: "default argument invalid",
errNamedParamHasToBeIdent: "named parameter has to be an identifier",
errNoReturnTypeForX: "no return type allowed for $1",
errConvNeedsOneArg: "a type conversion needs exactly one argument",
errInvalidPragmaX: ,
errXNotAllowedHere: "$1 not allowed here",
errXisNoType: "invalid type: '$1'",
errCircumNeedsPointer: "'[]' needs a pointer or reference type",
errInvalidExpression: "invalid expression",
errInvalidExpressionX: "invalid expression: '$1'",
errEnumHasNoValueX: "enum has no value '$1'",
,
errNoCommand: "no command given",
errInvalidCommandX: "invalid command: '$1'",
errXNeedsParamObjectType: ,
errTemplateInstantiationTooNested: "template instantiation too nested, try --evalTemplateLimit:N",
errMacroInstantiationTooNested: "macro instantiation too nested, try --evalMacroLimit:N",
errInstantiationFrom: "template/generic instantiation from here",
errInvalidIndexValueForTuple: "invalid index value for tuple subscript",
errCommandExpectsFilename: "command expects a filename argument",
errMainModuleMustBeSpecified: "please, specify a main module in the project configuration file",
errXExpected: "'$1' expected",
,
errCastToANonConcreteType: "cannot cast to a non concrete type: '$1'",
errInvalidSectionStart: "invalid section start",
errGridTableNotImplemented: "grid table is not implemented",
errGeneralParseError: "general parse error",
errNewSectionExpected: "new section expected",
errWhitespaceExpected: "whitespace expected, got '$1'",
errXisNoValidIndexFile: "'$1' is no valid index file",
errCannotRenderX: "cannot render reStructuredText element '$1'",
errVarVarTypeNotAllowed: ,
errInstantiateXExplicitly: "instantiate '$1' explicitly",
errOnlyACallOpCanBeDelegator: ,
errUsingNoSymbol: "'$1' is not a variable, constant or a proc name",
errMacroBodyDependsOnGenericTypes: "the macro body cannot be compiled, " &
"because the parameter '$1' has a generic type",
errDestructorNotGenericEnough: "Destructor signature is too specific. " &
"A destructor must be associated will all instantiations of a generic type",
errInlineIteratorsAsProcParams: "inline iterators can be used as parameters only for " &
"templates, macros and other inline iterators",
errXExpectsTwoArguments: "'$1' expects two arguments",
errXExpectsObjectTypes: "'$1' expects object types",
errXcanNeverBeOfThisSubtype: "'$1' can never be of this subtype",
errTooManyIterations: "interpretation requires too many iterations; " &
"if you are sure this is not a bug in your code edit " &
"compiler/vmdef.MaxLoopIterations and rebuild the compiler",
errFieldXNotFound: "field '$1' cannot be found",
errInvalidConversionFromTypeX: "invalid conversion from type '$1'",
errAssertionFailed: "assertion failed",
errCannotGenerateCodeForX: "cannot generate code for '$1'",
errXRequiresOneArgument: "$1 requires one parameter",
errUnhandledExceptionX: "unhandled exception: $1",
errCyclicTree: "macro returned a cyclic abstract syntax tree",
errXisNoMacroOrTemplate: "'$1' is no macro or template",
errXhasSideEffects: "'$1' can have side effects",
errWrongSymbolX:,
errIllegalCaptureX: "illegal capture '$1'",
errXCannotBeClosure: "'$1' cannot have 'closure' calling convention",
,
]#

8
compiler/destroyer.nim
View file

@ -132,6 +132,7 @@ type
destroys, topLevelVars: PNode destroys, topLevelVars: PNode
toDropBit: Table[int, PSym] toDropBit: Table[int, PSym]
graph: ModuleGraph graph: ModuleGraph
emptyNode: PNode
proc getTemp(c: var Con; typ: PType; info: TLineInfo): PNode = proc getTemp(c: var Con; typ: PType; info: TLineInfo): PNode =
# XXX why are temps fields in an object here? # XXX why are temps fields in an object here?
@ -243,7 +244,7 @@ proc genDestroy(c: Con; t: PType; dest: PNode): PNode =
genOp(t.destructor, "=destroy") genOp(t.destructor, "=destroy")
proc addTopVar(c: var Con; v: PNode) = proc addTopVar(c: var Con; v: PNode) =
c.topLevelVars.add newTree(nkIdentDefs, v, emptyNode, emptyNode) c.topLevelVars.add newTree(nkIdentDefs, v, c.emptyNode, c.emptyNode)
proc dropBit(c: var Con; s: PSym): PSym = proc dropBit(c: var Con; s: PSym): PSym =
result = c.toDropBit.getOrDefault(s.id) result = c.toDropBit.getOrDefault(s.id)
@ -253,7 +254,7 @@ proc registerDropBit(c: var Con; s: PSym) =
let result = newSym(skTemp, getIdent(s.name.s & "_AliveBit"), c.owner, s.info) let result = newSym(skTemp, getIdent(s.name.s & "_AliveBit"), c.owner, s.info)
result.typ = getSysType(c.graph, s.info, tyBool) result.typ = getSysType(c.graph, s.info, tyBool)
let trueVal = newIntTypeNode(nkIntLit, 1, result.typ) let trueVal = newIntTypeNode(nkIntLit, 1, result.typ)
c.topLevelVars.add newTree(nkIdentDefs, newSymNode result, emptyNode, trueVal) c.topLevelVars.add newTree(nkIdentDefs, newSymNode result, c.emptyNode, trueVal)
c.toDropBit[s.id] = result c.toDropBit[s.id] = result
# generate: # generate:
# if not sinkParam_AliveBit: `=destroy`(sinkParam) # if not sinkParam_AliveBit: `=destroy`(sinkParam)
@ -328,7 +329,7 @@ proc destructiveMoveVar(n: PNode; c: var Con): PNode =
var vpart = newNodeI(nkIdentDefs, tempAsNode.info, 3) var vpart = newNodeI(nkIdentDefs, tempAsNode.info, 3)
vpart.sons[0] = tempAsNode vpart.sons[0] = tempAsNode
vpart.sons[1] = ast.emptyNode vpart.sons[1] = c.emptyNode
vpart.sons[2] = n vpart.sons[2] = n
add(v, vpart) add(v, vpart)
@ -434,6 +435,7 @@ proc injectDestructorCalls*(g: ModuleGraph; owner: PSym; n: PNode): PNode =
c.topLevelVars = newNodeI(nkVarSection, n.info) c.topLevelVars = newNodeI(nkVarSection, n.info)
c.toDropBit = initTable[int, PSym]() c.toDropBit = initTable[int, PSym]()
c.graph = g c.graph = g
c.emptyNode = newNodeI(nkEmpty, n.info)
let cfg = constructCfg(owner, n) let cfg = constructCfg(owner, n)
shallowCopy(c.g, cfg) shallowCopy(c.g, cfg)
c.jumpTargets = initIntSet() c.jumpTargets = initIntSet()

4
compiler/evalffi.nim
View file

@ -442,7 +442,7 @@ proc callForeignFunction*(call: PNode): PNode =
libffi.call(cif, fn, retVal, args) libffi.call(cif, fn, retVal, args)
if retVal.isNil: if retVal.isNil:
result = emptyNode result = newNode(nkEmpty)
else: else:
result = unpack(retVal, typ.sons[0], nil) result = unpack(retVal, typ.sons[0], nil)
result.info = call.info result.info = call.info
@ -484,7 +484,7 @@ proc callForeignFunction*(fn: PNode, fntyp: PType,
libffi.call(cif, fn, retVal, cargs) libffi.call(cif, fn, retVal, cargs)
if retVal.isNil: if retVal.isNil:
result = emptyNode result = newNode(nkEmpty)
else: else:
result = unpack(retVal, fntyp.sons[0], nil) result = unpack(retVal, fntyp.sons[0], nil)
result.info = info result.info = info

2
compiler/evaltempl.nim
View file

@ -104,7 +104,7 @@ proc evalTemplateArgs(n: PNode, s: PSym; conf: ConfigRef; fromHlo: bool): PNode
let default = s.typ.n.sons[i].sym.ast let default = s.typ.n.sons[i].sym.ast
if default.isNil or default.kind == nkEmpty: if default.isNil or default.kind == nkEmpty:
localError(conf, n.info, errWrongNumberOfArguments) localError(conf, n.info, errWrongNumberOfArguments)
addSon(result, ast.emptyNode) addSon(result, newNodeI(nkEmpty, n.info))
else: else:
addSon(result, default.copyTree) addSon(result, default.copyTree)

4
compiler/lambdalifting.nim
View file

@ -629,7 +629,7 @@ proc transformYield(n: PNode; owner: PSym; d: DetectionPass;
addSon(a, retVal) addSon(a, retVal)
retStmt.add(a) retStmt.add(a)
else: else:
retStmt.add(emptyNode) retStmt.add(newNodeI(nkEmpty, n.info))
var stateLabelStmt = newNodeI(nkState, n.info) var stateLabelStmt = newNodeI(nkState, n.info)
stateLabelStmt.add(newIntTypeNode(nkIntLit, stateNo, stateLabelStmt.add(newIntTypeNode(nkIntLit, stateNo,
@ -923,7 +923,7 @@ proc liftForLoop*(g: ModuleGraph; body: PNode; owner: PSym): PNode =
body[i].sym.kind = skLet body[i].sym.kind = skLet
addSon(vpart, body[i]) addSon(vpart, body[i])
addSon(vpart, ast.emptyNode) # no explicit type addSon(vpart, newNodeI(nkEmpty, body.info)) # no explicit type
if not env.isNil: if not env.isNil:
call.sons[0] = makeClosure(g, call.sons[0].sym, env.newSymNode, body.info) call.sons[0] = makeClosure(g, call.sons[0].sym, env.newSymNode, body.info)
addSon(vpart, call) addSon(vpart, call)

22
compiler/lowerings.nim
View file

@ -30,8 +30,8 @@ proc newTupleAccess*(g: ModuleGraph; tup: PNode, i: int): PNode =
proc addVar*(father, v: PNode) = proc addVar*(father, v: PNode) =
var vpart = newNodeI(nkIdentDefs, v.info, 3) var vpart = newNodeI(nkIdentDefs, v.info, 3)
vpart.sons[0] = v vpart.sons[0] = v
vpart.sons[1] = ast.emptyNode vpart.sons[1] = newNodeI(nkEmpty, v.info)
vpart.sons[2] = ast.emptyNode vpart.sons[2] = vpart[1]
addSon(father, vpart) addSon(father, vpart)
proc newAsgnStmt(le, ri: PNode): PNode = proc newAsgnStmt(le, ri: PNode): PNode =
@ -83,7 +83,7 @@ proc lowerTupleUnpackingForAsgn*(n: PNode; owner: PSym): PNode =
var vpart = newNodeI(nkIdentDefs, tempAsNode.info, 3) var vpart = newNodeI(nkIdentDefs, tempAsNode.info, 3)
vpart.sons[0] = tempAsNode vpart.sons[0] = tempAsNode
vpart.sons[1] = ast.emptyNode vpart.sons[1] = newNodeI(nkEmpty, value.info)
vpart.sons[2] = value vpart.sons[2] = value
addSon(v, vpart) addSon(v, vpart)
result.add(v) result.add(v)
@ -104,7 +104,7 @@ proc lowerSwap*(n: PNode; owner: PSym): PNode =
var vpart = newNodeI(nkIdentDefs, v.info, 3) var vpart = newNodeI(nkIdentDefs, v.info, 3)
vpart.sons[0] = tempAsNode vpart.sons[0] = tempAsNode
vpart.sons[1] = ast.emptyNode vpart.sons[1] = newNodeI(nkEmpty, v.info)
vpart.sons[2] = n[1] vpart.sons[2] = n[1]
addSon(v, vpart) addSon(v, vpart)
@ -344,8 +344,8 @@ proc addLocalVar(g: ModuleGraph; varSection, varInit: PNode; owner: PSym; typ: P
var vpart = newNodeI(nkIdentDefs, varSection.info, 3) var vpart = newNodeI(nkIdentDefs, varSection.info, 3)
vpart.sons[0] = newSymNode(result) vpart.sons[0] = newSymNode(result)
vpart.sons[1] = ast.emptyNode vpart.sons[1] = newNodeI(nkEmpty, varSection.info)
vpart.sons[2] = if varInit.isNil: v else: ast.emptyNode vpart.sons[2] = if varInit.isNil: v else: vpart[1]
varSection.add vpart varSection.add vpart
if varInit != nil: if varInit != nil:
if useShallowCopy and typeNeedsNoDeepCopy(typ): if useShallowCopy and typeNeedsNoDeepCopy(typ):
@ -438,7 +438,7 @@ proc createWrapperProc(g: ModuleGraph; f: PNode; threadParam, argsParam: PSym;
body.add callCodegenProc(g, "barrierLeave", threadLocalBarrier.newSymNode) body.add callCodegenProc(g, "barrierLeave", threadLocalBarrier.newSymNode)
var params = newNodeI(nkFormalParams, f.info) var params = newNodeI(nkFormalParams, f.info)
params.add emptyNode params.add newNodeI(nkEmpty, f.info)
params.add threadParam.newSymNode params.add threadParam.newSymNode
params.add argsParam.newSymNode params.add argsParam.newSymNode
@ -454,12 +454,16 @@ proc createWrapperProc(g: ModuleGraph; f: PNode; threadParam, argsParam: PSym;
let name = (if f.kind == nkSym: f.sym.name.s else: genPrefix) & "Wrapper" let name = (if f.kind == nkSym: f.sym.name.s else: genPrefix) & "Wrapper"
result = newSym(skProc, getIdent(name), argsParam.owner, f.info, result = newSym(skProc, getIdent(name), argsParam.owner, f.info,
argsParam.options) argsParam.options)
result.ast = newProcNode(nkProcDef, f.info, body, params, newSymNode(result)) let emptyNode = newNodeI(nkEmpty, f.info)
result.ast = newProcNode(nkProcDef, f.info, body = body,
params = params, name = newSymNode(result), pattern = emptyNode,
genericParams = emptyNode, pragmas = emptyNode,
exceptions = emptyNode)
result.typ = t result.typ = t
proc createCastExpr(argsParam: PSym; objType: PType): PNode = proc createCastExpr(argsParam: PSym; objType: PType): PNode =
result = newNodeI(nkCast, argsParam.info) result = newNodeI(nkCast, argsParam.info)
result.add emptyNode result.add newNodeI(nkEmpty, argsParam.info)
result.add newSymNode(argsParam) result.add newSymNode(argsParam)
result.typ = newType(tyPtr, objType.owner) result.typ = newType(tyPtr, objType.owner)
result.typ.rawAddSon(objType) result.typ.rawAddSon(objType)

2
compiler/modulegraphs.nim
View file

@ -50,6 +50,7 @@ type
exposed*: TStrTable exposed*: TStrTable
intTypeCache*: array[-5..64, PType] intTypeCache*: array[-5..64, PType]
opContains*, opNot*: PSym opContains*, opNot*: PSym
emptyNode*: PNode
proc hash*(x: FileIndex): Hash {.borrow.} proc hash*(x: FileIndex): Hash {.borrow.}
@ -79,6 +80,7 @@ proc newModuleGraph*(config: ConfigRef = nil): ModuleGraph =
initStrTable(result.exposed) initStrTable(result.exposed)
result.opNot = createMagic(result, "not", mNot) result.opNot = createMagic(result, "not", mNot)
result.opContains = createMagic(result, "contains", mInSet) result.opContains = createMagic(result, "contains", mInSet)
result.emptyNode = newNode(nkEmpty)
proc resetAllModules*(g: ModuleGraph) = proc resetAllModules*(g: ModuleGraph) =
initStrTable(packageSyms) initStrTable(packageSyms)

92
compiler/parser.nim
View file

@ -40,6 +40,7 @@ type
tok*: TToken # The current token tok*: TToken # The current token
inPragma*: int # Pragma level inPragma*: int # Pragma level
inSemiStmtList*: int inSemiStmtList*: int
emptyNode: PNode
SymbolMode = enum SymbolMode = enum
smNormal, smAllowNil, smAfterDot smNormal, smAllowNil, smAfterDot
@ -93,6 +94,7 @@ proc openParser*(p: var TParser, fileIdx: FileIndex, inputStream: PLLStream,
getTok(p) # read the first token getTok(p) # read the first token
p.firstTok = true p.firstTok = true
p.strongSpaces = strongSpaces p.strongSpaces = strongSpaces
p.emptyNode = newNode(nkEmpty)
proc openParser*(p: var TParser, filename: string, inputStream: PLLStream, proc openParser*(p: var TParser, filename: string, inputStream: PLLStream,
cache: IdentCache; config: ConfigRef; cache: IdentCache; config: ConfigRef;
@ -333,7 +335,7 @@ proc parseSymbol(p: var TParser, mode = smNormal): PNode =
getTok(p) getTok(p)
else: else:
parMessage(p, errIdentifierExpected, p.tok) parMessage(p, errIdentifierExpected, p.tok)
result = ast.emptyNode result = p.emptyNode
of tkAccent: of tkAccent:
result = newNodeP(nkAccQuoted, p) result = newNodeP(nkAccQuoted, p)
getTok(p) getTok(p)
@ -364,7 +366,7 @@ proc parseSymbol(p: var TParser, mode = smNormal): PNode =
# But: this really sucks for idetools and keywords, so we don't do it # But: this really sucks for idetools and keywords, so we don't do it
# if it is a keyword: # if it is a keyword:
#if not isKeyword(p.tok.tokType): getTok(p) #if not isKeyword(p.tok.tokType): getTok(p)
result = ast.emptyNode result = p.emptyNode
proc colonOrEquals(p: var TParser, a: PNode): PNode = proc colonOrEquals(p: var TParser, a: PNode): PNode =
if p.tok.tokType == tkColon: if p.tok.tokType == tkColon:
@ -703,7 +705,7 @@ proc identOrLiteral(p: var TParser, mode: TPrimaryMode): PNode =
else: else:
parMessage(p, errExprExpected, p.tok) parMessage(p, errExprExpected, p.tok)
getTok(p) # we must consume a token here to prevend endless loops! getTok(p) # we must consume a token here to prevend endless loops!
result = ast.emptyNode result = p.emptyNode
proc namedParams(p: var TParser, callee: PNode, proc namedParams(p: var TParser, callee: PNode,
kind: TNodeKind, endTok: TTokType): PNode = kind: TNodeKind, endTok: TTokType): PNode =
@ -1015,7 +1017,7 @@ proc parseParamList(p: var TParser, retColon = true): PNode =
#| paramListColon = paramList? (':' optInd typeDesc)? #| paramListColon = paramList? (':' optInd typeDesc)?
var a: PNode var a: PNode
result = newNodeP(nkFormalParams, p) result = newNodeP(nkFormalParams, p)
addSon(result, ast.emptyNode) # return type addSon(result, p.emptyNode) # return type
let hasParLe = p.tok.tokType == tkParLe and p.tok.indent < 0 let hasParLe = p.tok.tokType == tkParLe and p.tok.indent < 0
if hasParLe: if hasParLe:
getTok(p) getTok(p)
@ -1047,13 +1049,13 @@ proc parseParamList(p: var TParser, retColon = true): PNode =
result.sons[0] = parseTypeDesc(p) result.sons[0] = parseTypeDesc(p)
elif not retColon and not hasParle: elif not retColon and not hasParle:
# Mark as "not there" in order to mark for deprecation in the semantic pass: # Mark as "not there" in order to mark for deprecation in the semantic pass:
result = ast.emptyNode result = p.emptyNode
proc optPragmas(p: var TParser): PNode = proc optPragmas(p: var TParser): PNode =
if p.tok.tokType == tkCurlyDotLe and (p.tok.indent < 0 or realInd(p)): if p.tok.tokType == tkCurlyDotLe and (p.tok.indent < 0 or realInd(p)):
result = parsePragma(p) result = parsePragma(p)
else: else:
result = ast.emptyNode result = p.emptyNode
proc parseDoBlock(p: var TParser; info: TLineInfo): PNode = proc parseDoBlock(p: var TParser; info: TLineInfo): PNode =
#| doBlock = 'do' paramListArrow pragmas? colcom stmt #| doBlock = 'do' paramListArrow pragmas? colcom stmt
@ -1062,7 +1064,9 @@ proc parseDoBlock(p: var TParser; info: TLineInfo): PNode =
colcom(p, result) colcom(p, result)
result = parseStmt(p) result = parseStmt(p)
if params.kind != nkEmpty: if params.kind != nkEmpty:
result = newProcNode(nkDo, info, result, params = params, pragmas = pragmas) result = newProcNode(nkDo, info,
body = result, params = params, name = p.emptyNode, pattern = p.emptyNode,
genericParams = p.emptyNode, pragmas = pragmas, exceptions = p.emptyNode)
proc parseProcExpr(p: var TParser; isExpr: bool; kind: TNodeKind): PNode = proc parseProcExpr(p: var TParser; isExpr: bool; kind: TNodeKind): PNode =
#| procExpr = 'proc' paramListColon pragmas? ('=' COMMENT? stmt)? #| procExpr = 'proc' paramListColon pragmas? ('=' COMMENT? stmt)?
@ -1075,9 +1079,9 @@ proc parseProcExpr(p: var TParser; isExpr: bool; kind: TNodeKind): PNode =
if p.tok.tokType == tkEquals and isExpr: if p.tok.tokType == tkEquals and isExpr:
getTok(p) getTok(p)
skipComment(p, result) skipComment(p, result)
result = newProcNode(kind, info, parseStmt(p), result = newProcNode(kind, info, body = parseStmt(p),
params = params, params = params, name = p.emptyNode, pattern = p.emptyNode,
pragmas = pragmas) genericParams = p.emptyNode, pragmas = pragmas, exceptions = p.emptyNode)
else: else:
result = newNodeI(nkProcTy, info) result = newNodeI(nkProcTy, info)
if hasSignature: if hasSignature:
@ -1244,8 +1248,8 @@ proc postExprBlocks(p: var TParser, x: PNode): PNode =
if p.tok.indent >= 0: return if p.tok.indent >= 0: return
var var
openingParams = emptyNode openingParams = p.emptyNode
openingPragmas = emptyNode openingPragmas = p.emptyNode
if p.tok.tokType == tkDo: if p.tok.tokType == tkDo:
getTok(p) getTok(p)
@ -1264,8 +1268,12 @@ proc postExprBlocks(p: var TParser, x: PNode): PNode =
stmtList.flags.incl nfBlockArg stmtList.flags.incl nfBlockArg
if openingParams.kind != nkEmpty: if openingParams.kind != nkEmpty:
result.add newProcNode(nkDo, stmtList.info, stmtList, result.add newProcNode(nkDo, stmtList.info, body = stmtList,
params = openingParams, pragmas = openingPragmas) params = openingParams,
name = p.emptyNode, pattern = p.emptyNode,
genericParams = p.emptyNode,
pragmas = openingPragmas,
exceptions = p.emptyNode)
else: else:
result.add stmtList result.add stmtList
@ -1424,10 +1432,10 @@ proc parseReturnOrRaise(p: var TParser, kind: TNodeKind): PNode =
getTok(p) getTok(p)
if p.tok.tokType == tkComment: if p.tok.tokType == tkComment:
skipComment(p, result) skipComment(p, result)
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
elif p.tok.indent >= 0 and p.tok.indent <= p.currInd or not isExprStart(p): elif p.tok.indent >= 0 and p.tok.indent <= p.currInd or not isExprStart(p):
# NL terminates: # NL terminates:
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
else: else:
var e = parseExpr(p) var e = parseExpr(p)
e = postExprBlocks(p, e) e = postExprBlocks(p, e)
@ -1568,7 +1576,7 @@ proc parseBlock(p: var TParser): PNode =
#| blockExpr = 'block' symbol? colcom stmt #| blockExpr = 'block' symbol? colcom stmt
result = newNodeP(nkBlockStmt, p) result = newNodeP(nkBlockStmt, p)
getTokNoInd(p) getTokNoInd(p)
if p.tok.tokType == tkColon: addSon(result, ast.emptyNode) if p.tok.tokType == tkColon: addSon(result, p.emptyNode)
else: addSon(result, parseSymbol(p)) else: addSon(result, parseSymbol(p))
colcom(p, result) colcom(p, result)
addSon(result, parseStmt(p)) addSon(result, parseStmt(p))
@ -1586,7 +1594,7 @@ proc parseAsm(p: var TParser): PNode =
result = newNodeP(nkAsmStmt, p) result = newNodeP(nkAsmStmt, p)
getTokNoInd(p) getTokNoInd(p)
if p.tok.tokType == tkCurlyDotLe: addSon(result, parsePragma(p)) if p.tok.tokType == tkCurlyDotLe: addSon(result, parsePragma(p))
else: addSon(result, ast.emptyNode) else: addSon(result, p.emptyNode)
case p.tok.tokType case p.tok.tokType
of tkStrLit: addSon(result, newStrNodeP(nkStrLit, p.tok.literal, p)) of tkStrLit: addSon(result, newStrNodeP(nkStrLit, p.tok.literal, p))
of tkRStrLit: addSon(result, newStrNodeP(nkRStrLit, p.tok.literal, p)) of tkRStrLit: addSon(result, newStrNodeP(nkRStrLit, p.tok.literal, p))
@ -1594,7 +1602,7 @@ proc parseAsm(p: var TParser): PNode =
newStrNodeP(nkTripleStrLit, p.tok.literal, p)) newStrNodeP(nkTripleStrLit, p.tok.literal, p))
else: else:
parMessage(p, "the 'asm' statement takes a string literal") parMessage(p, "the 'asm' statement takes a string literal")
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
return return
getTok(p) getTok(p)
@ -1625,13 +1633,13 @@ proc parseGenericParam(p: var TParser): PNode =
optInd(p, result) optInd(p, result)
addSon(result, parseExpr(p)) addSon(result, parseExpr(p))
else: else:
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
if p.tok.tokType == tkEquals: if p.tok.tokType == tkEquals:
getTok(p) getTok(p)
optInd(p, result) optInd(p, result)
addSon(result, parseExpr(p)) addSon(result, parseExpr(p))
else: else:
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
proc parseGenericParamList(p: var TParser): PNode = proc parseGenericParamList(p: var TParser): PNode =
#| genericParamList = '[' optInd #| genericParamList = '[' optInd
@ -1667,22 +1675,22 @@ proc parseRoutine(p: var TParser, kind: TNodeKind): PNode =
optInd(p, result) optInd(p, result)
addSon(result, identVis(p)) addSon(result, identVis(p))
if p.tok.tokType == tkCurlyLe and p.validInd: addSon(result, p.parsePattern) if p.tok.tokType == tkCurlyLe and p.validInd: addSon(result, p.parsePattern)
else: addSon(result, ast.emptyNode) else: addSon(result, p.emptyNode)
if p.tok.tokType == tkBracketLe and p.validInd: if p.tok.tokType == tkBracketLe and p.validInd:
result.add(p.parseGenericParamList) result.add(p.parseGenericParamList)
else: else:
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
addSon(result, p.parseParamList) addSon(result, p.parseParamList)
if p.tok.tokType == tkCurlyDotLe and p.validInd: addSon(result, p.parsePragma) if p.tok.tokType == tkCurlyDotLe and p.validInd: addSon(result, p.parsePragma)
else: addSon(result, ast.emptyNode) else: addSon(result, p.emptyNode)
# empty exception tracking: # empty exception tracking:
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
if p.tok.tokType == tkEquals and p.validInd: if p.tok.tokType == tkEquals and p.validInd:
getTok(p) getTok(p)
skipComment(p, result) skipComment(p, result)
addSon(result, parseStmt(p)) addSon(result, parseStmt(p))
else: else:
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
indAndComment(p, result) indAndComment(p, result)
proc newCommentStmt(p: var TParser): PNode = proc newCommentStmt(p: var TParser): PNode =
@ -1732,7 +1740,7 @@ proc parseConstant(p: var TParser): PNode =
optInd(p, result) optInd(p, result)
addSon(result, parseTypeDesc(p)) addSon(result, parseTypeDesc(p))
else: else:
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
eat(p, tkEquals) eat(p, tkEquals)
optInd(p, result) optInd(p, result)
addSon(result, parseExpr(p)) addSon(result, parseExpr(p))
@ -1742,7 +1750,7 @@ proc parseEnum(p: var TParser): PNode =
#| enum = 'enum' optInd (symbol optInd ('=' optInd expr COMMENT?)? comma?)+ #| enum = 'enum' optInd (symbol optInd ('=' optInd expr COMMENT?)? comma?)+
result = newNodeP(nkEnumTy, p) result = newNodeP(nkEnumTy, p)
getTok(p) getTok(p)
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
optInd(p, result) optInd(p, result)
flexComment(p, result) flexComment(p, result)
# progress guaranteed # progress guaranteed
@ -1813,7 +1821,7 @@ proc parseObjectCase(p: var TParser): PNode =
addSon(a, identWithPragma(p)) addSon(a, identWithPragma(p))
eat(p, tkColon) eat(p, tkColon)
addSon(a, parseTypeDesc(p)) addSon(a, parseTypeDesc(p))
addSon(a, ast.emptyNode) addSon(a, p.emptyNode)
addSon(result, a) addSon(result, a)
if p.tok.tokType == tkColon: getTok(p) if p.tok.tokType == tkColon: getTok(p)
flexComment(p, result) flexComment(p, result)
@ -1872,7 +1880,7 @@ proc parseObjectPart(p: var TParser): PNode =
result = newNodeP(nkNilLit, p) result = newNodeP(nkNilLit, p)
getTok(p) getTok(p)
else: else:
result = ast.emptyNode result = p.emptyNode
proc parseObject(p: var TParser): PNode = proc parseObject(p: var TParser): PNode =
#| object = 'object' pragma? ('of' typeDesc)? COMMENT? objectPart #| object = 'object' pragma? ('of' typeDesc)? COMMENT? objectPart
@ -1881,19 +1889,19 @@ proc parseObject(p: var TParser): PNode =
if p.tok.tokType == tkCurlyDotLe and p.validInd: if p.tok.tokType == tkCurlyDotLe and p.validInd:
addSon(result, parsePragma(p)) addSon(result, parsePragma(p))
else: else:
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
if p.tok.tokType == tkOf and p.tok.indent < 0: if p.tok.tokType == tkOf and p.tok.indent < 0:
var a = newNodeP(nkOfInherit, p) var a = newNodeP(nkOfInherit, p)
getTok(p) getTok(p)
addSon(a, parseTypeDesc(p)) addSon(a, parseTypeDesc(p))
addSon(result, a) addSon(result, a)
else: else:
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
if p.tok.tokType == tkComment: if p.tok.tokType == tkComment:
skipComment(p, result) skipComment(p, result)
# an initial IND{>} HAS to follow: # an initial IND{>} HAS to follow:
if not realInd(p): if not realInd(p):
addSon(result, emptyNode) addSon(result, p.emptyNode)
return return
addSon(result, parseObjectPart(p)) addSon(result, parseObjectPart(p))
@ -1928,7 +1936,7 @@ proc parseTypeClass(p: var TParser): PNode =
if p.tok.tokType == tkCurlyDotLe and p.validInd: if p.tok.tokType == tkCurlyDotLe and p.validInd:
addSon(result, parsePragma(p)) addSon(result, parsePragma(p))
else: else:
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
if p.tok.tokType == tkOf and p.tok.indent < 0: if p.tok.tokType == tkOf and p.tok.indent < 0:
var a = newNodeP(nkOfInherit, p) var a = newNodeP(nkOfInherit, p)
getTok(p) getTok(p)
@ -1939,12 +1947,12 @@ proc parseTypeClass(p: var TParser): PNode =
getTok(p) getTok(p)
addSon(result, a) addSon(result, a)
else: else:
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
if p.tok.tokType == tkComment: if p.tok.tokType == tkComment:
skipComment(p, result) skipComment(p, result)
# an initial IND{>} HAS to follow: # an initial IND{>} HAS to follow:
if not realInd(p): if not realInd(p):
addSon(result, emptyNode) addSon(result, p.emptyNode)
else: else:
addSon(result, parseStmt(p)) addSon(result, parseStmt(p))
@ -1957,14 +1965,14 @@ proc parseTypeDef(p: var TParser): PNode =
if p.tok.tokType == tkBracketLe and p.validInd: if p.tok.tokType == tkBracketLe and p.validInd:
addSon(result, parseGenericParamList(p)) addSon(result, parseGenericParamList(p))
else: else:
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
if p.tok.tokType == tkEquals: if p.tok.tokType == tkEquals:
result.info = parLineInfo(p) result.info = parLineInfo(p)
getTok(p) getTok(p)
optInd(p, result) optInd(p, result)
addSon(result, parseTypeDefAux(p)) addSon(result, parseTypeDefAux(p))
else: else:
addSon(result, ast.emptyNode) addSon(result, p.emptyNode)
indAndComment(p, result) # special extension! indAndComment(p, result) # special extension!
proc parseVarTuple(p: var TParser): PNode = proc parseVarTuple(p: var TParser): PNode =
@ -1979,7 +1987,7 @@ proc parseVarTuple(p: var TParser): PNode =
if p.tok.tokType != tkComma: break if p.tok.tokType != tkComma: break
getTok(p) getTok(p)
skipComment(p, a) skipComment(p, a)
addSon(result, ast.emptyNode) # no type desc addSon(result, p.emptyNode) # no type desc
optPar(p) optPar(p)
eat(p, tkParRi) eat(p, tkParRi)
eat(p, tkEquals) eat(p, tkEquals)
@ -2040,7 +2048,7 @@ proc simpleStmt(p: var TParser): PNode =
of tkComment: result = newCommentStmt(p) of tkComment: result = newCommentStmt(p)
else: else:
if isExprStart(p): result = parseExprStmt(p) if isExprStart(p): result = parseExprStmt(p)
else: result = ast.emptyNode else: result = p.emptyNode
if result.kind notin {nkEmpty, nkCommentStmt}: skipComment(p, result) if result.kind notin {nkEmpty, nkCommentStmt}: skipComment(p, result)
proc complexOrSimpleStmt(p: var TParser): PNode = proc complexOrSimpleStmt(p: var TParser): PNode =
@ -2136,7 +2144,7 @@ proc parseStmt(p: var TParser): PNode =
of tkIf, tkWhile, tkCase, tkTry, tkFor, tkBlock, tkAsm, tkProc, tkFunc, of tkIf, tkWhile, tkCase, tkTry, tkFor, tkBlock, tkAsm, tkProc, tkFunc,
tkIterator, tkMacro, tkType, tkConst, tkWhen, tkVar: tkIterator, tkMacro, tkType, tkConst, tkWhen, tkVar:
parMessage(p, "complex statement requires indentation") parMessage(p, "complex statement requires indentation")
result = ast.emptyNode result = p.emptyNode
else: else:
if p.inSemiStmtList > 0: if p.inSemiStmtList > 0:
result = simpleStmt(p) result = simpleStmt(p)
@ -2173,7 +2181,7 @@ proc parseAll(p: var TParser): PNode =
proc parseTopLevelStmt(p: var TParser): PNode = proc parseTopLevelStmt(p: var TParser): PNode =
## Implements an iterator which, when called repeatedly, returns the next ## Implements an iterator which, when called repeatedly, returns the next
## top-level statement or emptyNode if end of stream. ## top-level statement or emptyNode if end of stream.
result = ast.emptyNode result = p.emptyNode
# progress guaranteed # progress guaranteed
while true: while true:
if p.tok.indent != 0: if p.tok.indent != 0:

8
compiler/plugins/itersgen.nim
View file

@ -40,10 +40,10 @@ proc iterToProcImpl(c: PContext, n: PNode): PNode =
prc.typ.rawAddSon t prc.typ.rawAddSon t
let orig = iter.sym.ast let orig = iter.sym.ast
prc.ast = newProcNode(nkProcDef, n.info, prc.ast = newProcNode(nkProcDef, n.info,
name = newSymNode(prc), body = body, params = orig[paramsPos], name = newSymNode(prc),
params = orig[paramsPos], pattern = c.graph.emptyNode, genericParams = c.graph.emptyNode,
pragmas = orig[pragmasPos], pragmas = orig[pragmasPos], exceptions = c.graph.emptyNode)
body = body)
prc.ast.add iter.sym.ast.sons[resultPos] prc.ast.add iter.sym.ast.sons[resultPos]
addInterfaceDecl(c, prc) addInterfaceDecl(c, prc)

2
compiler/rodread.nim
View file

@ -966,7 +966,7 @@ proc getBody*(s: PSym): PNode =
## accessor. ## accessor.
assert s.kind in routineKinds assert s.kind in routineKinds
# prevent crashes due to incorrect macro transformations (bug #2377) # prevent crashes due to incorrect macro transformations (bug #2377)
if s.ast.isNil or bodyPos >= s.ast.len: return ast.emptyNode if s.ast.isNil or bodyPos >= s.ast.len: return newNodeI(nkEmpty, s.info)
result = s.ast.sons[bodyPos] result = s.ast.sons[bodyPos]
if result == nil: if result == nil:
assert s.offset != 0 assert s.offset != 0

2
compiler/sem.nim
View file

@ -594,7 +594,7 @@ proc myProcess(context: PPassContext, n: PNode): PNode =
c.suggestionsMade = true c.suggestionsMade = true
result = nil result = nil
else: else:
result = ast.emptyNode result = newNodeI(nkEmpty, n.info)
#if c.config.cmd == cmdIdeTools: findSuggest(c, n) #if c.config.cmd == cmdIdeTools: findSuggest(c, n)
rod.storeNode(c.module, result) rod.storeNode(c.module, result)

4
compiler/semasgn.nim
View file

@ -157,7 +157,7 @@ proc defaultOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
proc addVar(father, v, value: PNode) = proc addVar(father, v, value: PNode) =
var vpart = newNodeI(nkIdentDefs, v.info, 3) var vpart = newNodeI(nkIdentDefs, v.info, 3)
vpart.sons[0] = v vpart.sons[0] = v
vpart.sons[1] = ast.emptyNode vpart.sons[1] = newNodeI(nkEmpty, v.info)
vpart.sons[2] = value vpart.sons[2] = value
addSon(father, vpart) addSon(father, vpart)
@ -297,7 +297,7 @@ proc liftBody(c: PContext; typ: PType; kind: TTypeAttachedOp;
of attachedDestructor: typ.destructor = result of attachedDestructor: typ.destructor = result
var n = newNodeI(nkProcDef, info, bodyPos+1) var n = newNodeI(nkProcDef, info, bodyPos+1)
for i in 0 ..< n.len: n.sons[i] = emptyNode for i in 0 ..< n.len: n.sons[i] = newNodeI(nkEmpty, info)
n.sons[namePos] = newSymNode(result) n.sons[namePos] = newSymNode(result)
n.sons[paramsPos] = result.typ.n n.sons[paramsPos] = result.typ.n
n.sons[bodyPos] = body n.sons[bodyPos] = body

29
compiler/semexprs.nim
View file

@ -634,7 +634,7 @@ proc semStaticExpr(c: PContext, n: PNode): PNode =
result = evalStaticExpr(c.module, c.cache, c.graph, a, c.p.owner) result = evalStaticExpr(c.module, c.cache, c.graph, a, c.p.owner)
if result.isNil: if result.isNil:
localError(c.config, n.info, errCannotInterpretNodeX % renderTree(n)) localError(c.config, n.info, errCannotInterpretNodeX % renderTree(n))
result = emptyNode result = c.graph.emptyNode
else: else:
result = fixupTypeAfterEval(c, result, a) result = fixupTypeAfterEval(c, result, a)
@ -745,7 +745,7 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags): PNode =
if errorOutputs == {}: if errorOutputs == {}:
# speed up error generation: # speed up error generation:
globalError(c.config, n.info, "type mismatch") globalError(c.config, n.info, "type mismatch")
return emptyNode return c.graph.emptyNode
else: else:
var hasErrorType = false var hasErrorType = false
var msg = "type mismatch: got <" var msg = "type mismatch: got <"
@ -866,7 +866,7 @@ proc lookupInRecordAndBuildCheck(c: PContext, n, r: PNode, field: PIdent,
else: else:
if check == nil: if check == nil:
check = newNodeI(nkCheckedFieldExpr, n.info) check = newNodeI(nkCheckedFieldExpr, n.info)
addSon(check, ast.emptyNode) # make space for access node addSon(check, c.graph.emptyNode) # make space for access node
s = newNodeIT(nkCurly, n.info, setType) s = newNodeIT(nkCurly, n.info, setType)
for j in countup(0, sonsLen(it) - 2): addSon(s, copyTree(it.sons[j])) for j in countup(0, sonsLen(it) - 2): addSon(s, copyTree(it.sons[j]))
var inExpr = newNodeIT(nkCall, n.info, getSysType(c.graph, n.info, tyBool)) var inExpr = newNodeIT(nkCall, n.info, getSysType(c.graph, n.info, tyBool))
@ -881,7 +881,7 @@ proc lookupInRecordAndBuildCheck(c: PContext, n, r: PNode, field: PIdent,
if result != nil: if result != nil:
if check == nil: if check == nil:
check = newNodeI(nkCheckedFieldExpr, n.info) check = newNodeI(nkCheckedFieldExpr, n.info)
addSon(check, ast.emptyNode) # make space for access node addSon(check, c.graph.emptyNode) # make space for access node
var inExpr = newNodeIT(nkCall, n.info, getSysType(c.graph, n.info, tyBool)) var inExpr = newNodeIT(nkCall, n.info, getSysType(c.graph, n.info, tyBool))
addSon(inExpr, newSymNode(c.graph.opContains, n.info)) addSon(inExpr, newSymNode(c.graph.opContains, n.info))
addSon(inExpr, s) addSon(inExpr, s)
@ -938,7 +938,7 @@ proc readTypeParameter(c: PContext, typ: PType,
if rawTyp.n != nil: if rawTyp.n != nil:
return rawTyp.n return rawTyp.n
else: else:
return emptyNode return c.graph.emptyNode
else: else:
let foundTyp = makeTypeDesc(c, rawTyp) let foundTyp = makeTypeDesc(c, rawTyp)
return newSymNode(copySym(tParam.sym).linkTo(foundTyp), info) return newSymNode(copySym(tParam.sym).linkTo(foundTyp), info)
@ -1106,7 +1106,7 @@ proc builtinFieldAccess(c: PContext, n: PNode, flags: TExprFlags): PNode =
case t.kind case t.kind
of tyTypeParamsHolders: of tyTypeParamsHolders:
result = readTypeParameter(c, t, i, n.info) result = readTypeParameter(c, t, i, n.info)
if result == emptyNode: if result == c.graph.emptyNode:
result = n result = n
n.typ = makeTypeFromExpr(c, n.copyTree) n.typ = makeTypeFromExpr(c, n.copyTree)
return return
@ -1489,7 +1489,7 @@ proc semReturn(c: PContext, n: PNode): PNode =
n.sons[0] = semAsgn(c, a) n.sons[0] = semAsgn(c, a)
# optimize away ``result = result``: # optimize away ``result = result``:
if n[0][1].kind == nkSym and n[0][1].sym == c.p.resultSym: if n[0][1].kind == nkSym and n[0][1].sym == c.p.resultSym:
n.sons[0] = ast.emptyNode n.sons[0] = c.graph.emptyNode
else: else:
localError(c.config, n.info, errNoReturnTypeDeclared) localError(c.config, n.info, errNoReturnTypeDeclared)
else: else:
@ -1748,14 +1748,17 @@ proc semQuoteAst(c: PContext, n: PNode): PNode =
processQuotations(c, quotedBlock, op, quotes, ids) processQuotations(c, quotedBlock, op, quotes, ids)
var dummyTemplate = newProcNode( var dummyTemplate = newProcNode(
nkTemplateDef, quotedBlock.info, quotedBlock, nkTemplateDef, quotedBlock.info, body = quotedBlock,
name = newAnonSym(c, skTemplate, n.info).newSymNode) params = c.graph.emptyNode,
name = newAnonSym(c, skTemplate, n.info).newSymNode,
pattern = c.graph.emptyNode, genericParams = c.graph.emptyNode,
pragmas = c.graph.emptyNode, exceptions = c.graph.emptyNode)
if ids.len > 0: if ids.len > 0:
dummyTemplate.sons[paramsPos] = newNodeI(nkFormalParams, n.info) dummyTemplate.sons[paramsPos] = newNodeI(nkFormalParams, n.info)
dummyTemplate[paramsPos].add getSysSym(c.graph, n.info, "typed").newSymNode # return type dummyTemplate[paramsPos].add getSysSym(c.graph, n.info, "typed").newSymNode # return type
ids.add getSysSym(c.graph, n.info, "untyped").newSymNode # params type ids.add getSysSym(c.graph, n.info, "untyped").newSymNode # params type
ids.add emptyNode # no default value ids.add c.graph.emptyNode # no default value
dummyTemplate[paramsPos].add newNode(nkIdentDefs, n.info, ids) dummyTemplate[paramsPos].add newNode(nkIdentDefs, n.info, ids)
var tmpl = semTemplateDef(c, dummyTemplate) var tmpl = semTemplateDef(c, dummyTemplate)
@ -1913,7 +1916,7 @@ proc semMagic(c: PContext, n: PNode, s: PSym, flags: TExprFlags): PNode =
result.typ = typ result.typ = typ
result.add instantiateCreateFlowVarCall(c, typ, n.info).newSymNode result.add instantiateCreateFlowVarCall(c, typ, n.info).newSymNode
else: else:
result.add emptyNode result.add c.graph.emptyNode
of mProcCall: of mProcCall:
result = setMs(n, s) result = setMs(n, s)
result.sons[1] = semExpr(c, n.sons[1]) result.sons[1] = semExpr(c, n.sons[1])
@ -1944,10 +1947,10 @@ proc semMagic(c: PContext, n: PNode, s: PSym, flags: TExprFlags): PNode =
let imports = newTree(nkStmtList) let imports = newTree(nkStmtList)
extractImports(n.lastSon, imports) extractImports(n.lastSon, imports)
for imp in imports: c.runnableExamples.add imp for imp in imports: c.runnableExamples.add imp
c.runnableExamples.add newTree(nkBlockStmt, emptyNode, copyTree n.lastSon) c.runnableExamples.add newTree(nkBlockStmt, c.graph.emptyNode, copyTree n.lastSon)
result = setMs(n, s) result = setMs(n, s)
else: else:
result = emptyNode result = c.graph.emptyNode
else: else:
result = semDirectOp(c, n, flags) result = semDirectOp(c, n, flags)

2
compiler/semfields.nim
View file

@ -162,7 +162,7 @@ proc semForFields(c: PContext, n: PNode, m: TMagic): PNode =
# we avoid it now if we can: # we avoid it now if we can:
if containsNode(stmts, {nkBreakStmt}): if containsNode(stmts, {nkBreakStmt}):
var b = newNodeI(nkBreakStmt, n.info) var b = newNodeI(nkBreakStmt, n.info)
b.add(ast.emptyNode) b.add(newNodeI(nkEmpty, n.info))
stmts.add(b) stmts.add(b)
else: else:
result = stmts result = stmts

2
compiler/seminst.nim
View file

@ -328,7 +328,7 @@ proc generateInstance(c: PContext, fn: PSym, pt: TIdTable,
inc i inc i
if tfTriggersCompileTime in result.typ.flags: if tfTriggersCompileTime in result.typ.flags:
incl(result.flags, sfCompileTime) incl(result.flags, sfCompileTime)
n.sons[genericParamsPos] = ast.emptyNode n.sons[genericParamsPos] = c.graph.emptyNode
var oldPrc = genericCacheGet(fn, entry[], c.compilesContextId) var oldPrc = genericCacheGet(fn, entry[], c.compilesContextId)
if oldPrc == nil: if oldPrc == nil:
# we MUST not add potentially wrong instantiations to the caching mechanism. # we MUST not add potentially wrong instantiations to the caching mechanism.

2
compiler/semmagic.nim
View file

@ -154,7 +154,7 @@ proc evalTypeTrait(c: PContext; traitCall: PNode, operand: PType, context: PSym)
result = newIntNodeT(ord(not complexObj), traitCall, c.graph) result = newIntNodeT(ord(not complexObj), traitCall, c.graph)
else: else:
localError(c.config, traitCall.info, "unknown trait") localError(c.config, traitCall.info, "unknown trait")
result = emptyNode result = newNodeI(nkEmpty, traitCall.info)
proc semTypeTraits(c: PContext, n: PNode): PNode = proc semTypeTraits(c: PContext, n: PNode): PNode =
checkMinSonsLen(n, 2, c.config) checkMinSonsLen(n, 2, c.config)

2
compiler/semparallel.nim
View file

@ -438,7 +438,7 @@ proc transformSpawn(g: ModuleGraph; owner: PSym; n, barrier: PNode): PNode =
let t = b[1][0].typ.sons[0] let t = b[1][0].typ.sons[0]
if spawnResult(t, true) == srByVar: if spawnResult(t, true) == srByVar:
result.add wrapProcForSpawn(g, owner, m, b.typ, barrier, it[0]) result.add wrapProcForSpawn(g, owner, m, b.typ, barrier, it[0])
it.sons[it.len-1] = emptyNode it.sons[it.len-1] = newNodeI(nkEmpty, it.info)
else: else:
it.sons[it.len-1] = wrapProcForSpawn(g, owner, m, b.typ, barrier, nil) it.sons[it.len-1] = wrapProcForSpawn(g, owner, m, b.typ, barrier, nil)
if result.isNil: result = n if result.isNil: result = n

4
compiler/sempass2.nim
View file

@ -915,8 +915,8 @@ proc initEffects(g: ModuleGraph; effects: PNode; s: PSym; t: var TEffects) =
newSeq(effects.sons, effectListLen) newSeq(effects.sons, effectListLen)
effects.sons[exceptionEffects] = newNodeI(nkArgList, s.info) effects.sons[exceptionEffects] = newNodeI(nkArgList, s.info)
effects.sons[tagEffects] = newNodeI(nkArgList, s.info) effects.sons[tagEffects] = newNodeI(nkArgList, s.info)
effects.sons[usesEffects] = ast.emptyNode effects.sons[usesEffects] = g.emptyNode
effects.sons[writeEffects] = ast.emptyNode effects.sons[writeEffects] = g.emptyNode
t.exc = effects.sons[exceptionEffects] t.exc = effects.sons[exceptionEffects]
t.tags = effects.sons[tagEffects] t.tags = effects.sons[tagEffects]

16
compiler/semstmts.nim
View file

@ -394,7 +394,7 @@ proc isDiscardUnderscore(v: PSym): bool =
result = true result = true
proc semUsing(c: PContext; n: PNode): PNode = proc semUsing(c: PContext; n: PNode): PNode =
result = ast.emptyNode result = c.graph.emptyNode
if not isTopLevel(c): localError(c.config, n.info, errXOnlyAtModuleScope % "using") if not isTopLevel(c): localError(c.config, n.info, errXOnlyAtModuleScope % "using")
for i in countup(0, sonsLen(n)-1): for i in countup(0, sonsLen(n)-1):
var a = n.sons[i] var a = n.sons[i]
@ -481,7 +481,7 @@ proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode =
typ = semTypeNode(c, a.sons[length-2], nil) typ = semTypeNode(c, a.sons[length-2], nil)
else: else:
typ = nil typ = nil
var def: PNode = ast.emptyNode var def: PNode = c.graph.emptyNode
if a.sons[length-1].kind != nkEmpty: if a.sons[length-1].kind != nkEmpty:
def = semExprWithType(c, a.sons[length-1], {efAllowDestructor}) def = semExprWithType(c, a.sons[length-1], {efAllowDestructor})
if def.typ.kind == tyTypeDesc and c.p.owner.kind != skMacro: if def.typ.kind == tyTypeDesc and c.p.owner.kind != skMacro:
@ -1176,7 +1176,7 @@ proc semProcAnnotation(c: PContext, prc: PNode;
x.add(newSymNode(m)) x.add(newSymNode(m))
prc.sons[pragmasPos] = copyExcept(n, i) prc.sons[pragmasPos] = copyExcept(n, i)
if prc[pragmasPos].kind != nkEmpty and prc[pragmasPos].len == 0: if prc[pragmasPos].kind != nkEmpty and prc[pragmasPos].len == 0:
prc.sons[pragmasPos] = emptyNode prc.sons[pragmasPos] = c.graph.emptyNode
if it.kind in nkPragmaCallKinds and it.len > 1: if it.kind in nkPragmaCallKinds and it.len > 1:
# pass pragma arguments to the macro too: # pass pragma arguments to the macro too:
@ -1199,7 +1199,7 @@ proc setGenericParamsMisc(c: PContext; n: PNode): PNode =
# issue https://github.com/nim-lang/Nim/issues/1713 # issue https://github.com/nim-lang/Nim/issues/1713
result = semGenericParamList(c, orig) result = semGenericParamList(c, orig)
if n.sons[miscPos].kind == nkEmpty: if n.sons[miscPos].kind == nkEmpty:
n.sons[miscPos] = newTree(nkBracket, ast.emptyNode, orig) n.sons[miscPos] = newTree(nkBracket, c.graph.emptyNode, orig)
else: else:
n.sons[miscPos].sons[1] = orig n.sons[miscPos].sons[1] = orig
n.sons[genericParamsPos] = result n.sons[genericParamsPos] = result
@ -1270,7 +1270,7 @@ proc semInferredLambda(c: PContext, pt: TIdTable, n: PNode): PNode =
result = n result = n
s.ast = result s.ast = result
n.sons[namePos].sym = s n.sons[namePos].sym = s
n.sons[genericParamsPos] = emptyNode n.sons[genericParamsPos] = c.graph.emptyNode
# for LL we need to avoid wrong aliasing # for LL we need to avoid wrong aliasing
let params = copyTree n.typ.n let params = copyTree n.typ.n
n.sons[paramsPos] = params n.sons[paramsPos] = params
@ -1613,7 +1613,7 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
if s.kind == skMethod: semMethodPrototype(c, s, n) if s.kind == skMethod: semMethodPrototype(c, s, n)
if sfImportc in s.flags: if sfImportc in s.flags:
# so we just ignore the body after semantic checking for importc: # so we just ignore the body after semantic checking for importc:
n.sons[bodyPos] = ast.emptyNode n.sons[bodyPos] = c.graph.emptyNode
popProcCon(c) popProcCon(c)
else: else:
if s.kind == skMethod: semMethodPrototype(c, s, n) if s.kind == skMethod: semMethodPrototype(c, s, n)
@ -1692,7 +1692,7 @@ proc semMethod(c: PContext, n: PNode): PNode =
let ret = s.typ.sons[0] let ret = s.typ.sons[0]
disp.typ.sons[0] = ret disp.typ.sons[0] = ret
if disp.ast[resultPos].kind == nkSym: if disp.ast[resultPos].kind == nkSym:
if isEmptyType(ret): disp.ast.sons[resultPos] = emptyNode if isEmptyType(ret): disp.ast.sons[resultPos] = c.graph.emptyNode
else: disp.ast[resultPos].sym.typ = ret else: disp.ast[resultPos].sym.typ = ret
proc semConverterDef(c: PContext, n: PNode): PNode = proc semConverterDef(c: PContext, n: PNode): PNode =
@ -1771,7 +1771,7 @@ proc semStaticStmt(c: PContext, n: PNode): PNode =
n.sons[0] = a n.sons[0] = a
evalStaticStmt(c.module, c.cache, c.graph, a, c.p.owner) evalStaticStmt(c.module, c.cache, c.graph, a, c.p.owner)
result = newNodeI(nkDiscardStmt, n.info, 1) result = newNodeI(nkDiscardStmt, n.info, 1)
result.sons[0] = emptyNode result.sons[0] = c.graph.emptyNode
proc usesResult(n: PNode): bool = proc usesResult(n: PNode): bool =
# nkStmtList(expr) properly propagates the void context, # nkStmtList(expr) properly propagates the void context,

2
compiler/semtypes.nim
View file

@ -658,7 +658,7 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var IntSet, pos: var int,
var length = sonsLen(n) var length = sonsLen(n)
var a: PNode var a: PNode
if father.kind != nkRecList and length>=4: a = newNodeI(nkRecList, n.info) if father.kind != nkRecList and length>=4: a = newNodeI(nkRecList, n.info)
else: a = ast.emptyNode else: a = newNodeI(nkEmpty, n.info)
if n.sons[length-1].kind != nkEmpty: if n.sons[length-1].kind != nkEmpty:
localError(c.config, n.sons[length-1].info, errInitHereNotAllowed) localError(c.config, n.sons[length-1].info, errInitHereNotAllowed)
var typ: PType var typ: PType

9
compiler/sigmatch.nim
View file

@ -1774,7 +1774,7 @@ proc implicitConv(kind: TNodeKind, f: PType, arg: PNode, m: TCandidate,
else: else:
result.typ = f result.typ = f
if result.typ == nil: internalError(c.graph.config, arg.info, "implicitConv") if result.typ == nil: internalError(c.graph.config, arg.info, "implicitConv")
addSon(result, ast.emptyNode) addSon(result, c.graph.emptyNode)
addSon(result, arg) addSon(result, arg)
proc userConvMatch(c: PContext, m: var TCandidate, f, a: PType, proc userConvMatch(c: PContext, m: var TCandidate, f, a: PType,
@ -1993,7 +1993,10 @@ proc paramTypesMatchAux(m: var TCandidate, f, a: PType,
return arg return arg
elif a.kind == tyVoid and f.matchesVoidProc and argOrig.kind == nkStmtList: elif a.kind == tyVoid and f.matchesVoidProc and argOrig.kind == nkStmtList:
# lift do blocks without params to lambdas # lift do blocks without params to lambdas
let lifted = c.semExpr(c, newProcNode(nkDo, argOrig.info, argOrig), {}) let p = c.graph
let lifted = c.semExpr(c, newProcNode(nkDo, argOrig.info, body = argOrig,
params = p.emptyNode, name = p.emptyNode, pattern = p.emptyNode,
genericParams = p.emptyNode, pragmas = p.emptyNode, exceptions = p.emptyNode), {})
if f.kind == tyBuiltInTypeClass: if f.kind == tyBuiltInTypeClass:
inc m.genericMatches inc m.genericMatches
put(m, f, lifted.typ) put(m, f, lifted.typ)
@ -2354,7 +2357,7 @@ proc matches*(c: PContext, n, nOrig: PNode, m: var TCandidate) =
proc argtypeMatches*(c: PContext, f, a: PType): bool = proc argtypeMatches*(c: PContext, f, a: PType): bool =
var m: TCandidate var m: TCandidate
initCandidate(c, m, f) initCandidate(c, m, f)
let res = paramTypesMatch(m, f, a, ast.emptyNode, nil) let res = paramTypesMatch(m, f, a, c.graph.emptyNode, nil)
#instantiateGenericConverters(c, res, m) #instantiateGenericConverters(c, res, m)
# XXX this is used by patterns.nim too; I think it's better to not # XXX this is used by patterns.nim too; I think it's better to not
# instantiate generic converters for that # instantiate generic converters for that

2
compiler/suggest.nim
View file

@ -510,7 +510,7 @@ proc safeSemExpr*(c: PContext, n: PNode): PNode =
try: try:
result = c.semExpr(c, n) result = c.semExpr(c, n)
except ERecoverableError: except ERecoverableError:
result = ast.emptyNode result = c.graph.emptyNode
proc sugExpr(c: PContext, n: PNode, outputs: var Suggestions) = proc sugExpr(c: PContext, n: PNode, outputs: var Suggestions) =
if n.kind == nkDotExpr: if n.kind == nkDotExpr:

4
compiler/syntaxes.nim
View file

@ -38,7 +38,6 @@ proc parseAll*(p: var TParsers): PNode =
result = parser.parseAll(p.parser) result = parser.parseAll(p.parser)
of skinEndX: of skinEndX:
internalError(p.config, "parser to implement") internalError(p.config, "parser to implement")
result = ast.emptyNode
proc parseTopLevelStmt*(p: var TParsers): PNode = proc parseTopLevelStmt*(p: var TParsers): PNode =
case p.skin case p.skin
@ -46,7 +45,6 @@ proc parseTopLevelStmt*(p: var TParsers): PNode =
result = parser.parseTopLevelStmt(p.parser) result = parser.parseTopLevelStmt(p.parser)
of skinEndX: of skinEndX:
internalError(p.config, "parser to implement") internalError(p.config, "parser to implement")
result = ast.emptyNode
proc utf8Bom(s: string): int = proc utf8Bom(s: string): int =
if s.len >= 3 and s[0] == '\xEF' and s[1] == '\xBB' and s[2] == '\xBF': if s.len >= 3 and s[0] == '\xEF' and s[1] == '\xBB' and s[2] == '\xBF':
@ -62,7 +60,7 @@ proc containsShebang(s: string, i: int): bool =
proc parsePipe(filename: string, inputStream: PLLStream; cache: IdentCache; proc parsePipe(filename: string, inputStream: PLLStream; cache: IdentCache;
config: ConfigRef): PNode = config: ConfigRef): PNode =
result = ast.emptyNode result = newNode(nkEmpty)
var s = llStreamOpen(filename, fmRead) var s = llStreamOpen(filename, fmRead)
if s != nil: if s != nil:
var line = newStringOfCap(80) var line = newStringOfCap(80)

10
compiler/transf.nim
View file

@ -194,7 +194,7 @@ proc transformVarSection(c: PTransf, v: PNode): PTransNode =
idNodeTablePut(c.transCon.mapping, it.sons[j].sym, x) idNodeTablePut(c.transCon.mapping, it.sons[j].sym, x)
defs[j] = x.PTransNode defs[j] = x.PTransNode
assert(it.sons[L-2].kind == nkEmpty) assert(it.sons[L-2].kind == nkEmpty)
defs[L-2] = ast.emptyNode.PTransNode defs[L-2] = newNodeI(nkEmpty, it.info).PTransNode
defs[L-1] = transform(c, it.sons[L-1]) defs[L-1] = transform(c, it.sons[L-1])
result[i] = defs result[i] = defs
@ -393,7 +393,7 @@ proc generateThunk(c: PTransf; prc: PNode, dest: PType): PNode =
if c.graph.config.cmd == cmdCompileToJS: return prc if c.graph.config.cmd == cmdCompileToJS: return prc
result = newNodeIT(nkClosure, prc.info, dest) result = newNodeIT(nkClosure, prc.info, dest)
var conv = newNodeIT(nkHiddenSubConv, prc.info, dest) var conv = newNodeIT(nkHiddenSubConv, prc.info, dest)
conv.add(emptyNode) conv.add(newNodeI(nkEmpty, prc.info))
conv.add(prc) conv.add(prc)
if prc.kind == nkClosure: if prc.kind == nkClosure:
internalError(c.graph.config, prc.info, "closure to closure created") internalError(c.graph.config, prc.info, "closure to closure created")
@ -721,16 +721,16 @@ proc transformExceptBranch(c: PTransf, n: PNode): PTransNode =
let actions = newTransNode(nkStmtListExpr, n[1], 2) let actions = newTransNode(nkStmtListExpr, n[1], 2)
# Generating `let exc = (excType)(getCurrentException())` # Generating `let exc = (excType)(getCurrentException())`
# -> getCurrentException() # -> getCurrentException()
let excCall = PTransNode(callCodegenProc(c.graph, "getCurrentException", ast.emptyNode)) let excCall = PTransNode(callCodegenProc(c.graph, "getCurrentException", newNodeI(nkEmpty, n.info)))
# -> (excType) # -> (excType)
let convNode = newTransNode(nkHiddenSubConv, n[1].info, 2) let convNode = newTransNode(nkHiddenSubConv, n[1].info, 2)
convNode[0] = PTransNode(ast.emptyNode) convNode[0] = PTransNode(newNodeI(nkEmpty, n.info))
convNode[1] = excCall convNode[1] = excCall
PNode(convNode).typ = excTypeNode.typ.toRef() PNode(convNode).typ = excTypeNode.typ.toRef()
# -> let exc = ... # -> let exc = ...
let identDefs = newTransNode(nkIdentDefs, n[1].info, 3) let identDefs = newTransNode(nkIdentDefs, n[1].info, 3)
identDefs[0] = PTransNode(n[0][2]) identDefs[0] = PTransNode(n[0][2])
identDefs[1] = PTransNode(ast.emptyNode) identDefs[1] = PTransNode(newNodeI(nkEmpty, n.info))
identDefs[2] = convNode identDefs[2] = convNode
let letSection = newTransNode(nkLetSection, n[1].info, 1) let letSection = newTransNode(nkLetSection, n[1].info, 1)

6
compiler/vm.nim
View file

@ -213,7 +213,7 @@ proc putIntoNode(n: var PNode; x: TFullReg) =
if nfIsRef in x.node.flags: if nfIsRef in x.node.flags:
n = x.node n = x.node
else: else:
let destIsRef = nfIsRef in n.flags let destIsRef = nfIsRef in n.flags
n[] = x.node[] n[] = x.node[]
# Ref-ness must be kept for the destination # Ref-ness must be kept for the destination
if destIsRef: if destIsRef:
@ -1683,7 +1683,7 @@ proc myProcess(c: PPassContext, n: PNode): PNode =
# don't eval errornous code: # don't eval errornous code:
if c.oldErrorCount == c.config.errorCounter: if c.oldErrorCount == c.config.errorCounter:
evalStmt(c, n) evalStmt(c, n)
result = emptyNode result = newNodeI(nkEmpty, n.info)
else: else:
result = n result = n
c.oldErrorCount = c.config.errorCounter c.oldErrorCount = c.config.errorCounter
@ -1703,7 +1703,7 @@ proc evalConstExprAux(module: PSym; cache: IdentCache;
defer: c.mode = oldMode defer: c.mode = oldMode
c.mode = mode c.mode = mode
let start = genExpr(c, n, requiresValue = mode!=emStaticStmt) let start = genExpr(c, n, requiresValue = mode!=emStaticStmt)
if c.code[start].opcode == opcEof: return emptyNode if c.code[start].opcode == opcEof: return newNodeI(nkEmpty, n.info)
assert c.code[start].opcode != opcEof assert c.code[start].opcode != opcEof
when debugEchoCode: c.echoCode start when debugEchoCode: c.echoCode start
var tos = PStackFrame(prc: prc, comesFrom: 0, next: nil) var tos = PStackFrame(prc: prc, comesFrom: 0, next: nil)

22
compiler/vmdeps.nim
View file

@ -54,7 +54,7 @@ proc objectNode(n: PNode): PNode =
result = newNodeI(nkIdentDefs, n.info) result = newNodeI(nkIdentDefs, n.info)
result.add n # name result.add n # name
result.add mapTypeToAstX(n.sym.typ, n.info, true, false) # type result.add mapTypeToAstX(n.sym.typ, n.info, true, false) # type
result.add ast.emptyNode # no assigned value result.add newNodeI(nkEmpty, n.info) # no assigned value
else: else:
result = copyNode(n) result = copyNode(n)
for i in 0 ..< n.safeLen: for i in 0 ..< n.safeLen:
@ -69,7 +69,7 @@ proc mapTypeToAstX(t: PType; info: TLineInfo;
template mapTypeToAstR(t,info): untyped = mapTypeToAstX(t, info, inst, true) template mapTypeToAstR(t,info): untyped = mapTypeToAstX(t, info, inst, true)
template mapTypeToAst(t,i,info): untyped = template mapTypeToAst(t,i,info): untyped =
if i<t.len and t.sons[i]!=nil: mapTypeToAstX(t.sons[i], info, inst) if i<t.len and t.sons[i]!=nil: mapTypeToAstX(t.sons[i], info, inst)
else: ast.emptyNode else: newNodeI(nkEmpty, info)
template mapTypeToBracket(name, m, t, info): untyped = template mapTypeToBracket(name, m, t, info): untyped =
mapTypeToBracketX(name, m, t, info, inst) mapTypeToBracketX(name, m, t, info, inst)
template newNodeX(kind): untyped = template newNodeX(kind): untyped =
@ -78,7 +78,7 @@ proc mapTypeToAstX(t: PType; info: TLineInfo;
var id = newNodeX(nkIdentDefs) var id = newNodeX(nkIdentDefs)
id.add n # name id.add n # name
id.add mapTypeToAst(t, info) # type id.add mapTypeToAst(t, info) # type
id.add ast.emptyNode # no assigned value id.add newNodeI(nkEmpty, info) # no assigned value
id id
template newIdentDefs(s): untyped = newIdentDefs(s, s.typ) template newIdentDefs(s): untyped = newIdentDefs(s, s.typ)
@ -156,8 +156,8 @@ proc mapTypeToAstX(t: PType; info: TLineInfo;
of tyObject: of tyObject:
if inst: if inst:
result = newNodeX(nkObjectTy) result = newNodeX(nkObjectTy)
result.add ast.emptyNode # pragmas not reconstructed yet result.add newNodeI(nkEmpty, info) # pragmas not reconstructed yet
if t.sons[0] == nil: result.add ast.emptyNode # handle parent object if t.sons[0] == nil: result.add newNodeI(nkEmpty, info) # handle parent object
else: else:
var nn = newNodeX(nkOfInherit) var nn = newNodeX(nkOfInherit)
nn.add mapTypeToAst(t.sons[0], info) nn.add mapTypeToAst(t.sons[0], info)
@ -165,13 +165,13 @@ proc mapTypeToAstX(t: PType; info: TLineInfo;
if t.n.len > 0: if t.n.len > 0:
result.add objectNode(t.n) result.add objectNode(t.n)
else: else:
result.add ast.emptyNode result.add newNodeI(nkEmpty, info)
else: else:
if allowRecursion or t.sym == nil: if allowRecursion or t.sym == nil:
result = newNodeIT(nkObjectTy, if t.n.isNil: info else: t.n.info, t) result = newNodeIT(nkObjectTy, if t.n.isNil: info else: t.n.info, t)
result.add ast.emptyNode result.add newNodeI(nkEmpty, info)
if t.sons[0] == nil: if t.sons[0] == nil:
result.add ast.emptyNode result.add newNodeI(nkEmpty, info)
else: else:
result.add mapTypeToAst(t.sons[0], info) result.add mapTypeToAst(t.sons[0], info)
result.add copyTree(t.n) result.add copyTree(t.n)
@ -179,7 +179,7 @@ proc mapTypeToAstX(t: PType; info: TLineInfo;
result = atomicType(t.sym) result = atomicType(t.sym)
of tyEnum: of tyEnum:
result = newNodeIT(nkEnumTy, if t.n.isNil: info else: t.n.info, t) result = newNodeIT(nkEnumTy, if t.n.isNil: info else: t.n.info, t)
result.add ast.emptyNode # pragma node, currently always empty for enum result.add newNodeI(nkEmpty, info) # pragma node, currently always empty for enum
for c in t.n.sons: for c in t.n.sons:
result.add copyTree(c) result.add copyTree(c)
of tyTuple: of tyTuple:
@ -223,13 +223,13 @@ proc mapTypeToAstX(t: PType; info: TLineInfo;
result = newNodeX(nkProcTy) result = newNodeX(nkProcTy)
var fp = newNodeX(nkFormalParams) var fp = newNodeX(nkFormalParams)
if t.sons[0] == nil: if t.sons[0] == nil:
fp.add ast.emptyNode fp.add newNodeI(nkEmpty, info)
else: else:
fp.add mapTypeToAst(t.sons[0], t.n[0].info) fp.add mapTypeToAst(t.sons[0], t.n[0].info)
for i in 1..<t.sons.len: for i in 1..<t.sons.len:
fp.add newIdentDefs(t.n[i], t.sons[i]) fp.add newIdentDefs(t.n[i], t.sons[i])
result.add fp result.add fp
result.add ast.emptyNode # pragmas aren't reconstructed yet result.add newNodeI(nkEmpty, info) # pragmas aren't reconstructed yet
else: else:
result = mapTypeToBracket("proc", mNone, t, info) result = mapTypeToBracket("proc", mNone, t, info)
of tyOpenArray: result = mapTypeToBracket("openArray", mOpenArray, t, info) of tyOpenArray: result = mapTypeToBracket("openArray", mOpenArray, t, info)

4
compiler/vmgen.nim
View file

@ -1543,7 +1543,6 @@ proc getNullValueAux(obj: PNode, result: PNode; conf: ConfigRef) =
proc getNullValue(typ: PType, info: TLineInfo; conf: ConfigRef): PNode = proc getNullValue(typ: PType, info: TLineInfo; conf: ConfigRef): PNode =
var t = skipTypes(typ, abstractRange-{tyTypeDesc}) var t = skipTypes(typ, abstractRange-{tyTypeDesc})
result = emptyNode
case t.kind case t.kind
of tyBool, tyEnum, tyChar, tyInt..tyInt64: of tyBool, tyEnum, tyChar, tyInt..tyInt64:
result = newNodeIT(nkIntLit, info, t) result = newNodeIT(nkIntLit, info, t)
@ -1589,6 +1588,7 @@ proc getNullValue(typ: PType, info: TLineInfo; conf: ConfigRef): PNode =
result = newNodeIT(nkBracket, info, t) result = newNodeIT(nkBracket, info, t)
else: else:
globalError(conf, info, "cannot create null element for: " & $t.kind) globalError(conf, info, "cannot create null element for: " & $t.kind)
result = newNodeI(nkEmpty, info)
proc ldNullOpcode(t: PType): TOpcode = proc ldNullOpcode(t: PType): TOpcode =
assert t != nil assert t != nil
@ -2008,7 +2008,7 @@ proc genProc(c: PCtx; s: PSym): int =
#c.removeLastEof #c.removeLastEof
result = c.code.len+1 # skip the jump instruction result = c.code.len+1 # skip the jump instruction
if x.kind == nkEmpty: if x.kind == nkEmpty:
x = newTree(nkBracket, newIntNode(nkIntLit, result), ast.emptyNode) x = newTree(nkBracket, newIntNode(nkIntLit, result), x)
else: else:
x.sons[0] = newIntNode(nkIntLit, result) x.sons[0] = newIntNode(nkIntLit, result)
s.ast.sons[miscPos] = x s.ast.sons[miscPos] = x