mirrors/Nim
1
0
Fork 0
mirror of https://github.com/nim-lang/Nim.git synced 2026-02-12 22:33:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:Araq/Nimrod

Browse Source
This commit is contained in:
Araq
2012-04-01 01:01:25 +02:00
parent 3ef9f54cc1 8d698b2bdd
commit f788f603fe
27 changed files with 394 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
compiler/ast.nim
View File

@@ -258,7 +258,7 @@ type
tyGenericParam, # ``a`` in the above patterns
tyDistinct,
tyEnum,
tyOrdinal, # misnamed: should become 'tyConstraint'
tyOrdinal, # integer types (including enums and boolean)
tyArray,
tyObject,
tyTuple,
@@ -277,6 +277,7 @@ type
tyConst, tyMutable, tyVarargs,
tyIter, # unused
tyProxy # currently unused
tyTypeClass,
const
tyPureObject* = tyTuple
@@ -308,6 +309,8 @@ type
tfFromGeneric # type is an instantiation of a generic; this is needed
# because for instantiations of objects, structural
# type equality has to be used
tfAll # type class requires all constraints to be met (default)
tfAny # type class requires any constraint to be met
TTypeFlags* = set[TTypeFlag]
@@ -707,6 +710,15 @@ proc `[]`*(n: PNode, i: int): PNode {.inline.} =
var emptyNode* = newNode(nkEmpty)
# There is a single empty node that is shared! Do not overwrite it!
proc linkTo*(t: PType, s: PSym): PType {.discardable.} =
t.sym = s
s.typ = t
result = t
proc linkTo*(s: PSym, t: PType): PSym {.discardable.} =
t.sym = s
s.typ = t
result = s
const # for all kind of hash tables:
GrowthFactor* = 2 # must be power of 2, > 0

1
compiler/ccgcalls.nim
View File

@@ -130,6 +130,7 @@ proc genPrefixCall(p: BProc, le, ri: PNode, d: var TLoc) =
var length = sonsLen(ri)
for i in countup(1, length - 1):
assert(sonsLen(typ) == sonsLen(typ.n))
if ri.sons[i].typ.isCompileTimeOnly: continue
if i < sonsLen(typ):
assert(typ.n.sons[i].kind == nkSym)
app(pl, genArg(p, ri.sons[i], typ.n.sons[i].sym))

8
compiler/ccgtypes.nim
View File

@@ -7,6 +7,8 @@
# distribution, for details about the copyright.
#
# included from cgen.nim
# ------------------------- Name Mangling --------------------------------
proc mangle(name: string): string =
@@ -48,6 +50,9 @@ proc mangleName(s: PSym): PRope =
app(result, toRope(s.id))
s.loc.r = result
proc isCompileTimeOnly(t: PType): bool =
result = t.kind in {tyTypedesc, tyExpr}
proc getTypeName(typ: PType): PRope =
if (typ.sym != nil) and ({sfImportc, sfExportc} * typ.sym.flags != {}) and
(gCmd != cmdCompileToLLVM):
@@ -187,6 +192,7 @@ proc genProcParams(m: BModule, t: PType, rettype, params: var PRope,
for i in countup(1, sonsLen(t.n) - 1):
if t.n.sons[i].kind != nkSym: InternalError(t.n.info, "genProcParams")
var param = t.n.sons[i].sym
if isCompileTimeOnly(param.typ): continue
fillLoc(param.loc, locParam, param.typ, mangleName(param), OnStack)
app(params, getParamTypeDesc(m, param.typ, check))
if ccgIntroducedPtr(param):
@@ -206,8 +212,8 @@ proc genProcParams(m: BModule, t: PType, rettype, params: var PRope,
arr = arr.sons[0]
if i < sonsLen(t.n) - 1: app(params, ", ")
if (t.sons[0] != nil) and isInvalidReturnType(t.sons[0]):
if params != nil: app(params, ", ")
var arr = t.sons[0]
if params != nil: app(params, ", ")
app(params, getTypeDescAux(m, arr, check))
if (mapReturnType(t.sons[0]) != ctArray) or (gCmd == cmdCompileToLLVM):
app(params, "*")

4
compiler/ccgutils.nim
View File

@@ -82,9 +82,11 @@ proc GetUniqueType*(key: PType): PType =
if result == nil:
gCanonicalTypes[k] = key
result = key
of tyGenericParam, tyTypeClass:
InternalError("GetUniqueType")
of tyGenericInst, tyDistinct, tyOrdinal, tyMutable, tyConst, tyIter:
result = GetUniqueType(lastSon(key))
of tyArrayConstr, tyGenericInvokation, tyGenericBody, tyGenericParam,
of tyArrayConstr, tyGenericInvokation, tyGenericBody,
tyOpenArray, tyArray, tyTuple, tySet, tyRange,
tyPtr, tyRef, tySequence, tyForward, tyVarargs, tyProxy, tyVar:
# we have to do a slow linear search because types may need

1
compiler/cgen.nim
View File

@@ -606,6 +606,7 @@ proc genProcAux(m: BModule, prc: PSym) =
res.loc.s = OnUnknown
for i in countup(1, sonsLen(prc.typ.n) - 1):
var param = prc.typ.n.sons[i].sym
if param.typ.isCompileTimeOnly: continue
assignParam(p, param)
closureSetup(p, prc)
genStmts(p, prc.getBody) # modifies p.locals, p.init, etc.

2
compiler/ecmasgen.nim
View File

@@ -111,7 +111,7 @@ proc mapType(typ: PType): TEcmasTypeKind =
result = etyObject
of tyNil: result = etyNull
of tyGenericInst, tyGenericParam, tyGenericBody, tyGenericInvokation, tyNone,
tyForward, tyEmpty, tyExpr, tyStmt, tyTypeDesc:
tyForward, tyEmpty, tyExpr, tyStmt, tyTypeDesc, tyTypeClass:
result = etyNone
of tyProc: result = etyProc
of tyCString: result = etyString

15
compiler/evals.nim
View File

@@ -16,7 +16,7 @@
import
strutils, magicsys, lists, options, ast, astalgo, trees, treetab, nimsets,
msgs, os, condsyms, idents, renderer, types, passes, semfold, transf,
parser, ropes, rodread
parser, ropes, rodread, idgen
type
PStackFrame* = ref TStackFrame
@@ -843,6 +843,7 @@ proc evalParseStmt(c: PEvalContext, n: PNode): PNode =
result.typ = newType(tyStmt, c.module)
proc evalTemplateAux*(templ, actual: PNode, sym: PSym): PNode =
inc genSymBaseId
case templ.kind
of nkSym:
var p = templ.sym
@@ -866,26 +867,29 @@ proc evalTemplateArgs(n: PNode, s: PSym): PNode =
of nkCall, nkInfix, nkPrefix, nkPostfix, nkCommand, nkCallStrLit:
a = sonsLen(n)
else: a = 0
var f = sonsLen(s.typ)
var f = s.typ.sonsLen
if a > f: GlobalError(n.info, errWrongNumberOfArguments)
result = copyNode(n)
for i in countup(1, f - 1):
var arg = if i < a: n.sons[i] else: copyTree(s.typ.n.sons[i].sym.ast)
if arg == nil or arg.kind == nkEmpty:
LocalError(n.info, errWrongNumberOfArguments)
addSon(result, arg)
var evalTemplateCounter = 0
var evalTemplateCounter* = 0
# to prevent endless recursion in templates instantation
proc evalTemplate(n: PNode, sym: PSym): PNode =
proc evalTemplate*(n: PNode, sym: PSym): PNode =
inc(evalTemplateCounter)
if evalTemplateCounter > 100:
GlobalError(n.info, errTemplateInstantiationTooNested)
result = n
# replace each param by the corresponding node:
var args = evalTemplateArgs(n, sym)
result = evalTemplateAux(sym.getBody, args, sym)
dec(evalTemplateCounter)
proc evalExpandToAst(c: PEvalContext, original: PNode): PNode =
@@ -1312,6 +1316,7 @@ proc evalMacroCall*(c: PEvalContext, n: PNode, sym: PSym): PNode =
if evalTemplateCounter > 100:
GlobalError(n.info, errTemplateInstantiationTooNested)
inc genSymBaseId
var s = newStackFrame()
s.call = n
setlen(s.params, 2)

7
compiler/idgen.nim
View File

@@ -11,7 +11,7 @@
import idents, strutils, os, options
var gFrontEndId, gBackendId*: int
var gFrontEndId, gBackendId*, genSymBaseId*: int
const
debugIds* = false
@@ -25,7 +25,7 @@ proc registerID*(id: PIdObj) =
when debugIDs:
if id.id == -1 or ContainsOrIncl(usedIds, id.id):
InternalError("ID already used: " & $id.id)
proc getID*(): int {.inline.} =
result = gFrontEndId
inc(gFrontEndId)
@@ -34,6 +34,9 @@ proc backendId*(): int {.inline.} =
result = gBackendId
inc(gBackendId)
proc genSym*(basename: string): PIdent =
result = getIdent(basename & $genSymBaseId)
proc setId*(id: int) {.inline.} =
gFrontEndId = max(gFrontEndId, id + 1)

7
compiler/lookups.nim
View File

@@ -11,7 +11,7 @@
import
intsets, ast, astalgo, idents, semdata, types, msgs, options, rodread,
renderer
renderer, wordrecg, idgen
proc considerAcc*(n: PNode): PIdent =
case n.kind
@@ -21,6 +21,11 @@ proc considerAcc*(n: PNode): PIdent =
case n.len
of 0: GlobalError(n.info, errIdentifierExpected, renderTree(n))
of 1: result = considerAcc(n.sons[0])
of 2:
if n[0].ident.id == ord(wStar):
result = genSym(n[1].ident.s)
else:
result = getIdent(n[0].ident.s & n[1].ident.s)
else:
var id = ""
for i in 0.. <n.len:

5
compiler/msgs.nim
View File

@@ -662,3 +662,8 @@ proc InternalError*(info: TLineInfo, errMsg: string) =
proc InternalError*(errMsg: string) =
writeContext(UnknownLineInfo())
rawMessage(errInternal, errMsg)
template AssertNotNil*(e: expr): expr =
if(e == nil): InternalError($InstantiationInfo())
e

3
compiler/options.nim
View File

@@ -219,3 +219,6 @@ proc binaryStrSearch*(x: openarray[string], y: string): int =
return mid
result = - 1
# Can we keep this? I'm using it all the time
template nimdbg*: expr = c.filename.endsWith"nimdbg.nim"

2
compiler/sem.nim
View File

@@ -91,7 +91,7 @@ proc semConstExpr(c: PContext, n: PNode): PNode =
proc semAndEvalConstExpr(c: PContext, n: PNode): PNode =
result = semConstExpr(c, n)
include seminst, semcall
proc semAfterMacroCall(c: PContext, n: PNode, s: PSym): PNode =

10
compiler/semdata.nim
View File

@@ -180,14 +180,16 @@ proc addToLib(lib: PLib, sym: PSym) =
sym.annex = lib
proc makePtrType(c: PContext, baseType: PType): PType =
if (baseType == nil): InternalError("makePtrType")
result = newTypeS(tyPtr, c)
addSon(result, baseType)
addSon(result, baseType.AssertNotNil)
proc makeVarType(c: PContext, baseType: PType): PType =
if (baseType == nil): InternalError("makeVarType")
result = newTypeS(tyVar, c)
addSon(result, baseType)
addSon(result, baseType.AssertNotNil)
proc makeTypeDesc*(c: PContext, typ: PType): PType =
result = newTypeS(tyTypeDesc, c)
result.addSon(typ.AssertNotNil)
proc newTypeS(kind: TTypeKind, c: PContext): PType =
result = newType(kind, getCurrOwner())

44
compiler/semexprs.nim
View File

@@ -10,10 +10,12 @@
# this module does the semantic checking for expressions
# included from sem.nim
proc semExprOrTypedesc(c: PContext, n: PNode): PNode
proc semTemplateExpr(c: PContext, n: PNode, s: PSym, semCheck = true): PNode =
markUsed(n, s)
pushInfoContext(n.info)
result = evalTemplate(c, n, s)
result = evalTemplate(n, s)
if semCheck: result = semAfterMacroCall(c, result, s)
popInfoContext()
@@ -93,6 +95,8 @@ proc semSym(c: PContext, n: PNode, s: PSym, flags: TExprFlags): PNode =
# if a proc accesses a global variable, it is not side effect free:
if sfGlobal in s.flags:
incl(c.p.owner.flags, sfSideEffect)
elif s.kind == skParam and s.typ.kind == tyExpr:
return s.typ.n
elif s.owner != c.p.owner and s.owner.kind != skModule and
c.p.owner.typ != nil and not IsGenericRoutine(s.owner):
c.p.owner.typ.callConv = ccClosure
@@ -111,7 +115,7 @@ proc semSym(c: PContext, n: PNode, s: PSym, flags: TExprFlags): PNode =
else:
markUsed(n, s)
result = newSymNode(s, n.info)
proc checkConversionBetweenObjects(info: TLineInfo, castDest, src: PType) =
var diff = inheritanceDiff(castDest, src)
if diff == high(int):
@@ -247,16 +251,31 @@ proc semIs(c: PContext, n: PNode): PNode =
else:
GlobalError(n.info, errXExpectsTwoArguments, "is")
proc semExprOrTypedesc(c: PContext, n: PNode): PNode =
# XXX: Currently, semExprWithType will return the same type
# for nodes such as (100) or (int).
# This is inappropriate. The type of the first expression
# should be "int", while the type of the second one should
# be typeDesc(int).
# Ideally, this should be fixed in semExpr, but right now
# there are probably users that depend on the present behavior.
# XXX: Investigate current uses of efAllowType and fix them to
# work with tyTypeDesc.
result = semExprWithType(c, n, {efAllowType})
if result.kind == nkSym and result.sym.kind == skType and
result.typ.kind != tyTypeDesc:
result.typ = makeTypeDesc(c, result.typ)
proc semOpAux(c: PContext, n: PNode) =
for i in countup(1, sonsLen(n) - 1):
var a = n.sons[i]
if a.kind == nkExprEqExpr and sonsLen(a) == 2:
var info = a.sons[0].info
a.sons[0] = newIdentNode(considerAcc(a.sons[0]), info)
a.sons[1] = semExprWithType(c, a.sons[1], {efAllowType})
a.sons[1] = semExprOrTypedesc(c, a.sons[1])
a.typ = a.sons[1].typ
else:
n.sons[i] = semExprWithType(c, a, {efAllowType})
n.sons[i] = semExprOrTypedesc(c, a)
proc overloadedCallOpr(c: PContext, n: PNode): PNode =
# quick check if there is *any* () operator overloaded:
@@ -822,7 +841,7 @@ proc semDeref(c: PContext, n: PNode): PNode =
of tyRef, tyPtr: n.typ = t.sons[0]
else: result = nil
#GlobalError(n.sons[0].info, errCircumNeedsPointer)
proc semSubscript(c: PContext, n: PNode, flags: TExprFlags): PNode =
## returns nil if not a built-in subscript operator; also called for the
## checking of assignments
@@ -833,7 +852,7 @@ proc semSubscript(c: PContext, n: PNode, flags: TExprFlags): PNode =
result.add(x[0])
return
checkMinSonsLen(n, 2)
n.sons[0] = semExprWithType(c, n.sons[0], flags - {efAllowType})
n.sons[0] = semExprOrTypedesc(c, n.sons[0])
var arr = skipTypes(n.sons[0].typ, {tyGenericInst, tyVar, tyPtr, tyRef})
case arr.kind
of tyArray, tyOpenArray, tyArrayConstr, tySequence, tyString, tyCString:
@@ -848,6 +867,11 @@ proc semSubscript(c: PContext, n: PNode, flags: TExprFlags): PNode =
result = n
result.typ = elemType(arr)
#GlobalError(n.info, errIndexTypesDoNotMatch)
of tyTypeDesc:
result = n.sons[0] # The result so far is a tyTypeDesc bound to
# a tyGenericBody. The line below will substitute
# it with the instantiated type.
result.typ.sons[0] = semTypeNode(c, n, nil).linkTo(result.sym)
of tyTuple:
checkSonsLen(n, 2)
n.sons[0] = makeDeref(n.sons[0])
@@ -1024,7 +1048,7 @@ proc semExpandToAst(c: PContext, n: PNode, magicSym: PSym,
markUsed(n, expandedSym)
for i in countup(1, macroCall.len-1):
macroCall.sons[i] = semExprWithType(c, macroCall[i], {efAllowType})
macroCall.sons[i] = semExprWithType(c, macroCall[i], {})
# Preserve the magic symbol in order to be handled in evals.nim
n.sons[0] = newSymNode(magicSym, n.info)
@@ -1287,6 +1311,12 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
of nkBind:
Message(n.info, warnDeprecated, "bind")
result = semExpr(c, n.sons[0], flags)
of nkTypeOfExpr:
var typ = semTypeNode(c, n, nil)
if typ.sym == nil:
typ = copyType(typ, typ.owner, true)
typ.linkTo(newSym(skType, getIdent"typedesc", typ.owner))
result = newSymNode(typ.sym, n.info)
of nkCall, nkInfix, nkPrefix, nkPostfix, nkCommand, nkCallStrLit:
# check if it is an expression macro:
checkMinSonsLen(n, 1)

4
compiler/seminst.nim
View File

@@ -20,7 +20,7 @@ proc instantiateGenericParamList(c: PContext, n: PNode, pt: TIdTable,
if a.kind != nkSym:
InternalError(a.info, "instantiateGenericParamList; no symbol")
var q = a.sym
if q.typ.kind notin {tyTypeDesc, tyGenericParam}: continue
if q.typ.kind notin {tyTypeDesc, tyGenericParam, tyTypeClass, tyExpr}: continue
var s = newSym(skType, q.name, getCurrOwner())
s.info = q.info
s.flags = s.flags + {sfUsed, sfFromGeneric}
@@ -107,8 +107,6 @@ proc sideEffectsCheck(c: PContext, s: PSym) =
s.ast.sons[genericParamsPos].kind == nkEmpty:
c.threadEntries.add(s)
template nimdbg: expr = c.filename.endsWith"nimdbg.nim"
proc applyConcreteTypesToSig(genericProc: PSym, concTypes: seq[PType]): PType =
# XXX: This is intended to replace the use of semParamList in generateInstance.
# The results of semParamList's analysis are already encoded in the original

61
compiler/semtempl.nim
View File

@@ -9,67 +9,6 @@
# included from sem.nim
proc isExpr(n: PNode): bool =
# returns true if ``n`` looks like an expression
case n.kind
of nkIdent..nkNilLit:
result = true
of nkCall..pred(nkAsgn):
for i in countup(0, sonsLen(n) - 1):
if not isExpr(n.sons[i]):
return false
result = true
else: result = false
proc isTypeDesc(n: PNode): bool =
# returns true if ``n`` looks like a type desc
case n.kind
of nkIdent, nkSym, nkType:
result = true
of nkDotExpr, nkBracketExpr:
for i in countup(0, sonsLen(n) - 1):
if not isTypeDesc(n.sons[i]):
return false
result = true
of nkTypeOfExpr..nkEnumTy:
result = true
else: result = false
var evalTemplateCounter: int = 0
# to prevend endless recursion in templates instantation
proc evalTemplateArgs(c: PContext, n: PNode, s: PSym): PNode =
var
f, a: int
arg: PNode
f = sonsLen(s.typ)
# if the template has zero arguments, it can be called without ``()``
# `n` is then a nkSym or something similar
case n.kind
of nkCall, nkInfix, nkPrefix, nkPostfix, nkCommand, nkCallStrLit:
a = sonsLen(n)
else: a = 0
if a > f: LocalError(n.info, errWrongNumberOfArguments)
result = copyNode(n)
for i in countup(1, f - 1):
if i < a: arg = n.sons[i]
else: arg = copyTree(s.typ.n.sons[i].sym.ast)
if arg == nil or arg.kind == nkEmpty:
LocalError(n.info, errWrongNumberOfArguments)
addSon(result, arg)
proc evalTemplate*(c: PContext, n: PNode, sym: PSym): PNode =
var args: PNode
inc(evalTemplateCounter)
if evalTemplateCounter <= 100:
# replace each param by the corresponding node:
args = evalTemplateArgs(c, n, sym)
result = evalTemplateAux(sym.getBody, args, sym)
dec(evalTemplateCounter)
else:
GlobalError(n.info, errTemplateInstantiationTooNested)
result = n
proc symChoice(c: PContext, n: PNode, s: PSym): PNode =
var
a: PSym

151
compiler/semtypes.nim
View File

@@ -180,6 +180,8 @@ proc semTypeIdent(c: PContext, n: PNode): PSym =
result = qualifiedLookup(c, n, {checkAmbiguity, checkUndeclared})
if result != nil:
markUsed(n, result)
if result.kind == skParam and result.typ.kind == tyTypeDesc:
return result.typ.sons[0].sym
if result.kind != skType: GlobalError(n.info, errTypeExpected)
if result.typ.kind != tyGenericParam:
# XXX get rid of this hack!
@@ -470,42 +472,6 @@ proc semObjectNode(c: PContext, n: PNode, prev: PType): PType =
result.n = newNodeI(nkRecList, n.info)
semRecordNodeAux(c, n.sons[2], check, pos, result.n, result.sym)
proc addTypeVarsOfGenericBody(c: PContext, t: PType, genericParams: PNode,
cl: var TIntSet): PType =
result = t
if t == nil: return
if ContainsOrIncl(cl, t.id): return
case t.kind
of tyGenericBody:
result = newTypeS(tyGenericInvokation, c)
addSon(result, t)
for i in countup(0, sonsLen(t) - 2):
if t.sons[i].kind != tyGenericParam:
InternalError("addTypeVarsOfGenericBody")
# do not declare ``TKey`` twice:
#if not ContainsOrIncl(cl, t.sons[i].sym.ident.id):
var s = copySym(t.sons[i].sym)
s.position = sonsLen(genericParams)
if s.typ == nil or s.typ.kind != tyGenericParam:
InternalError("addTypeVarsOfGenericBody 2")
addDecl(c, s)
addSon(genericParams, newSymNode(s))
addSon(result, t.sons[i])
of tyGenericInst:
var L = sonsLen(t) - 1
t.sons[L] = addTypeVarsOfGenericBody(c, t.sons[L], genericParams, cl)
of tyGenericInvokation:
for i in countup(1, sonsLen(t) - 1):
t.sons[i] = addTypeVarsOfGenericBody(c, t.sons[i], genericParams, cl)
else:
for i in countup(0, sonsLen(t) - 1):
t.sons[i] = addTypeVarsOfGenericBody(c, t.sons[i], genericParams, cl)
proc paramType(c: PContext, n, genericParams: PNode, cl: var TIntSet): PType =
result = semTypeNode(c, n, nil)
if genericParams != nil and sonsLen(genericParams) == 0:
result = addTypeVarsOfGenericBody(c, result, genericParams, cl)
proc addParamOrResult(c: PContext, param: PSym, kind: TSymKind) =
if kind == skMacro and param.typ.kind in {tyTypeDesc, tyExpr, tyStmt}:
let nn = getSysSym"PNimrodNode"
@@ -515,8 +481,43 @@ proc addParamOrResult(c: PContext, param: PSym, kind: TSymKind) =
else:
addDecl(c, param)
proc isTypeClass(c: PContext, t: PType): bool =
return t.kind in {tyExpr}
proc paramTypeClass(c: PContext, paramType: PType, procKind: TSymKind):
tuple[typ: PType, id: PIdent] =
# if typ is not-nil, the param should be turned into a generic param
# if id is not nil, the generic param will bind just once (see below)
case paramType.kind:
of tyExpr:
if procKind notin {skTemplate, skMacro}:
if paramType.sonsLen == 0:
# proc(a, b: expr)
# no constraints, treat like generic param
result.typ = newTypeS(tyGenericParam, c)
else:
# proc(a: expr{string}, b: expr{nkLambda})
# overload on compile time values and AST trees
result.typ = newTypeS(tyExpr, c)
result.typ.sons = paramType.sons
of tyTypeDesc:
if procKind notin {skTemplate, skMacro}:
result.typ = newTypeS(tyTypeDesc, c)
result.typ.sons = paramType.sons
of tyDistinct:
# type T1 = distinct expr
# type S1 = distinct Sortable
# proc x(a, b: T1, c, d: S1)
# This forces bindOnce behavior for the type class, equivalent to
# proc x[T, S](a, b: T, c, d: S)
result = paramTypeClass(c, paramType.lastSon, procKind)
result.id = paramType.sym.name
of tyGenericBody:
# type Foo[T] = object
# proc x(a: Foo, b: Foo)
result.typ = newTypeS(tyTypeClass, c)
result.typ.addSon(paramType)
result.id = paramType.sym.name # bindOnce by default
of tyTypeClass:
result.typ = copyType(paramType, getCurrOwner(), false)
else: nil
proc semProcTypeNode(c: PContext, n, genericParams: PNode,
prev: PType, kind: TSymKind): PType =
@@ -546,9 +547,8 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
hasDefault = a.sons[length-1].kind != nkEmpty
if hasType:
typ = paramType(c, a.sons[length-2], genericParams, cl)
#if matchType(typ, [(tyVar, 0)], tyGenericInvokation):
# debug a.sons[length-2][0][1]
typ = semTypeNode(c, a.sons[length-2], nil)
if hasDefault:
def = semExprWithType(c, a.sons[length-1])
# check type compability between def.typ and typ:
@@ -566,40 +566,46 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
if skipTypes(typ, {tyGenericInst}).kind == tyEmpty: continue
for j in countup(0, length-3):
var arg = newSymS(skParam, a.sons[j], c)
arg.typ = typ
if kind notin {skTemplate, skMacro} and isTypeClass(c, typ):
let typeClassParamId = getIdent(":tcls_" & $i & "_" & $j)
var endingType = typ
var (typeClass, paramTypId) = paramTypeClass(c, typ, kind)
if typeClass != nil:
if paramTypId == nil: paramTypId = getIdent(arg.name.s & ":type")
if genericParams == nil:
# genericParams is nil when the proc is being instantiated
# the resolved type will be in scope then
var s = SymtabGet(c.tab, typeClassParamId)
arg.typ = s.typ
endingType = SymtabGet(c.tab, paramTypId).AssertNotNil.typ
else:
var s = newSym(skType, typeClassParamId, getCurrOwner())
s.typ = newTypeS(tyGenericParam, c)
s.typ.sym = s
s.position = genericParams.len
genericParams.addSon(newSymNode(s))
arg.typ = s.typ
block addImplicitGeneric:
# is this a bindOnce type class already present in the param list?
for i in countup(0, genericParams.len - 1):
if genericParams.sons[i].sym.name == paramTypId:
endingType = genericParams.sons[i].typ
break addImplicitGeneric
var s = newSym(skType, paramTypId, getCurrOwner())
s.typ = typeClass
s.typ.sym = s
s.position = genericParams.len
genericParams.addSon(newSymNode(s))
endingType = typeClass
arg.typ = endingType
arg.position = counter
inc(counter)
if def != nil and def.kind != nkEmpty: arg.ast = copyTree(def)
if ContainsOrIncl(check, arg.name.id):
LocalError(a.sons[j].info, errAttemptToRedefine, arg.name.s)
addSon(result.n, newSymNode(arg))
addSon(result, typ)
addSon(result, endingType)
addParamOrResult(c, arg, kind)
if n.sons[0].kind != nkEmpty:
var r = paramType(c, n.sons[0], genericParams, cl)
if n.sons[0].kind != nkEmpty:
var r = semTypeNode(c, n.sons[0], nil)
# turn explicit 'void' return type into 'nil' because the rest of the
# compiler only checks for 'nil':
if skipTypes(r, {tyGenericInst}).kind != tyEmpty:
result.sons[0] = r
res.typ = result.sons[0]
#if matchType(result, [(tyProc, 1), (tyVar, 0)], tyGenericInvokation):
# debug result
proc semStmtListType(c: PContext, n: PNode, prev: PType): PType =
checkMinSonsLen(n, 1)
@@ -666,9 +672,10 @@ proc semGeneric(c: PContext, n: PNode, s: PSym, prev: PType): PType =
if s.ast == nil: GlobalError(n.info, errCannotInstantiateX, s.name.s)
result = instGenericContainer(c, n, result)
proc semExpandToType(c: PContext, n: PNode, sym: PSym): PType =
proc semTypeFromMacro(c: PContext, n: PNode): PType =
# Expands a macro or template until a type is returned
# results in GlobalError if the macro expands to something different
var sym = expectMacroOrTemplateCall(c, n)
markUsed(n, sym)
case sym.kind
of skMacro:
@@ -678,7 +685,7 @@ proc semExpandToType(c: PContext, n: PNode, sym: PSym): PType =
else:
GlobalError(n.info, errXisNoMacroOrTemplate, n.renderTree)
proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
result = nil
if gCmd == cmdIdeTools: suggestExpr(c, n)
case n.kind
@@ -691,9 +698,27 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
if sonsLen(n) == 1: result = semTypeNode(c, n.sons[0], prev)
else: GlobalError(n.info, errTypeExpected)
of nkCallKinds:
# expand macros and templates
var expandedSym = expectMacroOrTemplateCall(c, n)
result = semExpandToType(c, n, expandedSym)
let op = n.sons[0].ident.id
if op in {ord(wAnd), ord(wOr)}:
var
t1 = semTypeNode(c, n.sons[1], nil)
t2 = semTypeNode(c, n.sons[2], nil)
if t1 == nil: GlobalError(n.sons[1].info, errTypeExpected)
elif t2 == nil: GlobalError(n.sons[2].info, errTypeExpected)
else:
result = newTypeS(tyTypeClass, c)
result.addSon(t1)
result.addSon(t2)
result.flags.incl(if op == ord(wAnd): tfAll else: tfAny)
else:
result = semTypeFromMacro(c, n)
of nkCurlyExpr:
result = semTypeNode(c, n.sons[0], nil)
if result != nil:
result = copyType(result, getCurrOwner(), false)
for i in countup(1, n.len - 1):
result.addSon(semTypeNode(c, n.sons[i], nil))
of nkWhenStmt:
var whenResult = semWhen(c, n, false)
if whenResult.kind == nkStmtList: whenResult.kind = nkStmtListType
@@ -794,7 +819,7 @@ proc processMagicType(c: PContext, m: PSym) =
else: GlobalError(m.info, errTypeExpected)
proc newConstraint(c: PContext, k: TTypeKind): PType =
result = newTypeS(tyOrdinal, c)
result = newTypeS(tyTypeClass, c)
result.addSon(newTypeS(k, c))
proc semGenericConstraints(c: PContext, n: PNode, result: PType) =

1
compiler/semtypinst.nim
View File

@@ -202,6 +202,7 @@ proc ReplaceTypeVarsT*(cl: var TReplTypeVars, t: PType): PType =
result = t
if t == nil: return
case t.kind
of tyTypeClass: nil
of tyGenericParam:
result = lookupTypeVar(cl, t)
if result.kind == tyGenericInvokation:

83
compiler/sigmatch.nim
View File

@@ -35,7 +35,7 @@ type
TTypeRelation* = enum # order is important!
isNone, isConvertible, isIntConv, isSubtype,
isGeneric,
isGeneric
isEqual
proc initCandidateAux(c: var TCandidate, callee: PType) {.inline.} =
@@ -208,10 +208,32 @@ proc tupleRel(mapping: var TIdTable, f, a: PType): TTypeRelation =
var y = a.n.sons[i].sym
if x.name.id != y.name.id: return isNone
proc constraintRel(mapping: var TIdTable, f, a: PType): TTypeRelation =
result = isNone
if f.kind == a.kind: result = isGeneric
proc matchTypeClass(mapping: var TIdTable, f, a: PType): TTypeRelation =
for i in countup(0, f.sonsLen - 1):
let son = f.sons[i]
var match = son.kind == a.kind
if not match:
case son.kind
of tyGenericBody:
if a.kind == tyGenericInst and a.sons[0] == son:
match = true
put(mapping, f, a)
of tyTypeClass:
match = matchTypeClass(mapping, son, a) == isGeneric
else: nil
if tfAny in f.flags:
if match == true:
return isGeneric
else:
if match == false:
return isNone
# if the loop finished without returning, either all constraints matched
# or none of them matched.
result = if tfAny in f.flags: isNone else: isGeneric
proc procTypeRel(mapping: var TIdTable, f, a: PType): TTypeRelation =
proc inconsistentVarTypes(f, a: PType): bool {.inline.} =
result = f.kind != a.kind and (f.kind == tyVar or a.kind == tyVar)
@@ -261,7 +283,8 @@ proc typeRel(mapping: var TIdTable, f, a: PType): TTypeRelation =
assert(a != nil)
if a.kind == tyGenericInst and
skipTypes(f, {tyVar}).kind notin {
tyGenericBody, tyGenericInvokation, tyGenericParam}:
tyGenericBody, tyGenericInvokation,
tyGenericParam, tyTypeClass }:
return typeRel(mapping, f, lastSon(a))
if a.kind == tyVar and f.kind != tyVar:
return typeRel(mapping, f, a.sons[0])
@@ -340,11 +363,8 @@ proc typeRel(mapping: var TIdTable, f, a: PType): TTypeRelation =
result = typeRel(mapping, f.sons[0], a.sons[0])
if result < isGeneric: result = isNone
else: nil
of tyOrdinal:
if f.sons[0].kind != tyGenericParam:
# some constraint:
result = constraintRel(mapping, f.sons[0], a)
elif isOrdinalType(a):
of tyOrdinal:
if isOrdinalType(a):
var x = if a.kind == tyOrdinal: a.sons[0] else: a
result = typeRel(mapping, f.sons[0], x)
if result < isGeneric: result = isNone
@@ -415,7 +435,7 @@ proc typeRel(mapping: var TIdTable, f, a: PType): TTypeRelation =
of tyGenericBody:
let ff = lastSon(f)
if ff != nil: result = typeRel(mapping, ff, a)
of tyGenericInvokation:
of tyGenericInvokation:
assert(f.sons[0].kind == tyGenericBody)
if a.kind == tyGenericInvokation:
#InternalError("typeRel: tyGenericInvokation -> tyGenericInvokation")
@@ -463,7 +483,19 @@ proc typeRel(mapping: var TIdTable, f, a: PType): TTypeRelation =
result = isGeneric
else:
result = typeRel(mapping, x, a) # check if it fits
of tyExpr, tyStmt, tyTypeDesc:
of tyTypeClass:
result = matchTypeClass(mapping, f, a)
if result == isGeneric: put(mapping, f, a)
of tyTypeDesc:
if a.kind == tyTypeDesc:
if f.sonsLen == 0:
result = isGeneric
else:
result = matchTypeClass(mapping, f, a.sons[0])
if result == isGeneric: put(mapping, f, a)
else:
result = isNone
of tyExpr, tyStmt:
result = isGeneric
else: internalError("typeRel(" & $f.kind & ')')
@@ -506,9 +538,34 @@ proc userConvMatch(c: PContext, m: var TCandidate, f, a: PType,
inc(m.convMatches)
return
proc ParamTypesMatchAux(c: PContext, m: var TCandidate, f, a: PType,
arg, argOrig: PNode): PNode =
var r = typeRel(m.bindings, f, a)
var r: TTypeRelation
if f.kind == tyExpr:
if f.sonsLen == 0:
r = isGeneric
else:
let match = matchTypeClass(m.bindings, f, a)
if match != isGeneric: r = isNone
else:
# XXX: Ideally, this should happen much earlier somewhere near
# semOpAux, but to do that, we need to be able to query the
# overload set to determine whether compile-time value is expected
# for the param before entering the full-blown sigmatch algorithm.
# This is related to the immediate pragma since querying the
# overload set could help there too.
var evaluated = c.semConstExpr(c, arg)
if evaluated != nil:
r = isGeneric
arg.typ = newTypeS(tyExpr, c)
arg.typ.n = evaluated
if r == isGeneric:
put(m.bindings, f, arg.typ)
else:
r = typeRel(m.bindings, f, a)
case r
of isConvertible:
inc(m.convMatches)

2
compiler/transf.nim
View File

@@ -429,7 +429,7 @@ proc transformConv(c: PTransf, n: PNode): PTransNode =
result = generateThunk(c, x, dest).ptransnode
else:
result = transformSons(c, n)
of tyGenericParam, tyOrdinal:
of tyGenericParam, tyOrdinal, tyTypeClass:
result = transform(c, n.sons[1])
# happens sometimes for generated assignments, etc.
else:

19
compiler/types.nim
View File

@@ -50,13 +50,13 @@ proc enumHasHoles*(t: PType): bool
const
abstractPtrs* = {tyVar, tyPtr, tyRef, tyGenericInst, tyDistinct, tyOrdinal,
tyConst, tyMutable}
abstractVar* = {tyVar, tyGenericInst, tyDistinct, tyOrdinal,
abstractVar* = {tyVar, tyGenericInst, tyDistinct, tyOrdinal,
tyConst, tyMutable}
abstractRange* = {tyGenericInst, tyRange, tyDistinct, tyOrdinal,
tyConst, tyMutable}
abstractVarRange* = {tyGenericInst, tyRange, tyVar, tyDistinct, tyOrdinal,
tyConst, tyMutable}
abstractInst* = {tyGenericInst, tyDistinct, tyOrdinal, tyConst, tyMutable}
abstractInst* = {tyGenericInst, tyDistinct, tyConst, tyMutable, tyOrdinal}
skipPtrs* = {tyVar, tyPtr, tyRef, tyGenericInst, tyConst, tyMutable}
@@ -383,7 +383,7 @@ proc TypeToString(typ: PType, prefer: TPreferedDesc = preferName): string =
"int16", "int32", "int64", "float", "float32", "float64", "float128",
"uint", "uint8", "uint16", "uint32", "uint64", "bignum", "const ",
"!", "varargs[$1]", "iter[$1]", "proxy[$1]"]
"!", "varargs[$1]", "iter[$1]", "proxy[$1]", "TypeClass" ]
var t = typ
result = ""
if t == nil: return
@@ -729,9 +729,11 @@ proc SameTypeAux(x, y: PType, c: var TSameTypeClosure): bool =
while a.kind == tyDistinct: a = a.sons[0]
if a.kind != b.kind: return false
case a.Kind
of tyEmpty, tyChar, tyBool, tyNil, tyPointer, tyString, tyCString,
tyInt..tyBigNum, tyExpr, tyStmt, tyTypeDesc:
of tyEmpty, tyChar, tyBool, tyNil, tyPointer, tyString, tyCString,
tyInt..tyBigNum, tyStmt:
result = true
of tyExpr:
result = ExprStructuralEquivalent(a.n, b.n)
of tyObject:
IfFastObjectTypeCheckFailed(a, b):
CycleCheck()
@@ -748,8 +750,9 @@ proc SameTypeAux(x, y: PType, c: var TSameTypeClosure): bool =
result = sameTuple(a, b, c)
of tyGenericInst: result = sameTypeAux(lastSon(a), lastSon(b), c)
of tyGenericParam, tyGenericInvokation, tyGenericBody, tySequence,
tyOrdinal, tyOpenArray, tySet, tyRef, tyPtr, tyVar, tyArrayConstr,
tyArray, tyProc, tyConst, tyMutable, tyVarargs, tyIter:
tyOpenArray, tySet, tyRef, tyPtr, tyVar, tyArrayConstr,
tyArray, tyProc, tyConst, tyMutable, tyVarargs, tyIter,
tyOrdinal, tyTypeDesc, tyTypeClass:
if sonsLen(a) == sonsLen(b):
CycleCheck()
result = true
@@ -845,7 +848,7 @@ proc typeAllowedAux(marker: var TIntSet, typ: PType, kind: TSymKind): bool =
result = typeAllowedAux(marker, t.sons[0], skResult)
of tyExpr, tyStmt, tyTypeDesc:
result = true
of tyGenericBody, tyGenericParam, tyForward, tyNone, tyGenericInvokation:
of tyGenericBody, tyGenericParam, tyForward, tyNone, tyGenericInvokation, tyTypeClass:
result = false #InternalError('shit found');
of tyEmpty, tyNil:
result = kind == skConst

28
lib/system.nim
View File

@@ -2177,7 +2177,7 @@ proc InstantiationInfo*(index = -1): tuple[filename: string, line: int] {.
## This is only useful for advanced meta programming. See the implementation
## of `assert` for an example.
proc raiseAssert(msg: string) {.noinline.} =
proc raiseAssert*(msg: string) {.noinline.} =
raise newException(EAssertionFailed, msg)
template assert*(cond: bool, msg = "") =
@@ -2186,7 +2186,7 @@ template assert*(cond: bool, msg = "") =
## raises an ``EAssertionFailure`` exception. However, the compiler may
## not generate any code at all for ``assert`` if it is advised to do so.
## Use ``assert`` for debugging purposes only.
bind raiseAssert, InstantiationInfo
bind InstantiationInfo
when compileOption("assertions"):
{.line.}:
if not cond:
@@ -2195,11 +2195,33 @@ template assert*(cond: bool, msg = "") =
template doAssert*(cond: bool, msg = "") =
## same as `assert` but is always turned on and not affected by the
## ``--assertions`` command line switch.
bind raiseAssert, InstantiationInfo
bind InstantiationInfo
{.line: InstantiationInfo().}:
if not cond:
raiseAssert(astToStr(cond) & ' ' & msg)
template onFailedAssert*(msg: expr, code: stmt): stmt =
## Sets an assertion failure handler that will intercept any assert statements
## following `onFailedAssert` in the current lexical scope.
## Can be defined multiple times in a single function.
##
## .. code-block:: nimrod
##
## proc example(x: int): TErrorCode =
## onFailedAssert(msg):
## log msg
## return E_FAIL
##
## assert(...)
##
## onFailedAssert(msg):
## raise newException(EMyException, msg)
##
## assert(...)
##
template raiseAssert(msgIMPL: string): stmt =
let `msg` = msgIMPL
code
proc shallow*[T](s: var seq[T]) {.noSideEffect, inline.} =
## marks a sequence `s` as `shallow`:idx:. Subsequent assignments will not

12
tests/compile/tgensym.nim Normal file
View File

@@ -0,0 +1,12 @@
template hygienic(val: expr) =
var `*x` = val
stdout.write `*x`
var x = 100
hygienic 1
hygienic 2
hygienic 3
echo x

34
tests/compile/ttypeclasses.nim Normal file
View File

@@ -0,0 +1,34 @@
type
TFoo[T] = object
val: T
T1 = distinct expr
T2 = distinct expr
proc takesExpr(x, y) =
echo x, y
proc same(x, y: T1) =
echo x, y
proc takesFoo(x, y: TFoo) =
echo x.val, y.val
proc takes2Types(x,y: T1, z: T2) =
echo x, y, z
takesExpr(1, 2)
takesExpr(1, "xxx")
takesExpr[bool, int](true, 0)
same(1, 2)
same("test", "test")
var f: TFoo[int]
f.val = 10
takesFoo(f, f)
takes2Types(1, 1, "string")
takes2Types[string, int]("test", "test", 1)

17
tests/run/tmemoization.nim Normal file
View File

@@ -0,0 +1,17 @@
discard """
msg: "test 1\ntest 2"
output: "TEST 1\nTEST 2\nTEST 2"
"""
import strutils
proc foo(s: expr{string}): string =
static: echo s
const R = s.toUpper
return R
echo foo("test 1")
echo foo("test 2")
echo foo("test " & $2)

35
tests/run/ttypedesc1.nim Normal file
View File

@@ -0,0 +1,35 @@
import unittest
type
TFoo[T, U] = object
x: T
y: U
proc foo(T: typedesc{float}, a: expr): string =
result = "float " & $(a.len > 5)
proc foo(T: typedesc{TFoo}, a: int): string =
result = "TFoo " & $(a)
proc foo(T: typedesc{int or bool}): string =
var a: T
a = 10
result = "int or bool " & ($a)
template foo(T: typedesc{seq}): expr = "seq"
test "types can be used as proc params":
check foo(TFoo[int, float], 1000) == "TFoo 1000"
var f = 10.0
check foo(float, "long string") == "float true"
check foo(type(f), [1, 2, 3]) == "float false"
check foo(int) == "int or bool 10"
check foo(seq[int]) == "seq"
check foo(seq[TFoo[bool, string]]) == "seq"
when false:
proc foo(T: typedesc{seq}, s: T) = nil

0
tests/run/uexpr.nim → tests/run/utypeclasses.nim
View File