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

clean up tyMutable remnants

Browse source
This commit is contained in:
Jacek Sieka 2016-10-24 23:30:10 +08:00
commit f5c3eb6a25
10 changed files with 37 additions and 44 deletions
Download patch file Download diff file Expand all files Collapse all files

6
compiler/ast.nim
View file

@ -349,9 +349,9 @@ type
tyInt, tyInt8, tyInt16, tyInt32, tyInt64, # signed integers tyInt, tyInt8, tyInt16, tyInt32, tyInt64, # signed integers
tyFloat, tyFloat32, tyFloat64, tyFloat128, tyFloat, tyFloat32, tyFloat64, tyFloat128,
tyUInt, tyUInt8, tyUInt16, tyUInt32, tyUInt64, tyUInt, tyUInt8, tyUInt16, tyUInt32, tyUInt64,
tyUnused0, tyUnused0, tyUnused1, tyUnused2,
tyUnused1, tyMutable, tyVarargs, tyVarargs,
tyUnused tyUnused,
tyProxy # used as errornous type (for idetools) tyProxy # used as errornous type (for idetools)
tyBuiltInTypeClass #\ tyBuiltInTypeClass #\

4
compiler/ccgtypes.nim
View file

@ -122,7 +122,7 @@ proc mapType(typ: PType): TCTypeKind =
of tyOpenArray, tyArrayConstr, tyArray, tyVarargs: result = ctArray of tyOpenArray, tyArrayConstr, tyArray, tyVarargs: result = ctArray
of tyObject, tyTuple: result = ctStruct of tyObject, tyTuple: result = ctStruct
of tyGenericBody, tyGenericInst, tyGenericParam, tyDistinct, tyOrdinal, of tyGenericBody, tyGenericInst, tyGenericParam, tyDistinct, tyOrdinal,
tyMutable, tyTypeDesc: tyTypeDesc:
result = mapType(lastSon(typ)) result = mapType(lastSon(typ))
of tyEnum: of tyEnum:
if firstOrd(typ) < 0: if firstOrd(typ) < 0:
@ -711,7 +711,7 @@ proc getTypeDescAux(m: BModule, typ: PType, check: var IntSet): Rope =
of 1, 2, 4, 8: addf(m.s[cfsTypes], "typedef NU$2 $1;$n", [result, rope(s*8)]) of 1, 2, 4, 8: addf(m.s[cfsTypes], "typedef NU$2 $1;$n", [result, rope(s*8)])
else: addf(m.s[cfsTypes], "typedef NU8 $1[$2];$n", else: addf(m.s[cfsTypes], "typedef NU8 $1[$2];$n",
[result, rope(getSize(t))]) [result, rope(getSize(t))])
of tyGenericInst, tyDistinct, tyOrdinal, tyMutable, tyTypeDesc: of tyGenericInst, tyDistinct, tyOrdinal, tyTypeDesc:
result = getTypeDescAux(m, lastSon(t), check) result = getTypeDescAux(m, lastSon(t), check)
else: else:
internalError("getTypeDescAux(" & $t.kind & ')') internalError("getTypeDescAux(" & $t.kind & ')')

4
compiler/ccgutils.nim
View file

@ -106,7 +106,7 @@ proc getUniqueType*(key: PType): PType =
of tyDistinct: of tyDistinct:
if key.deepCopy != nil: result = key if key.deepCopy != nil: result = key
else: result = getUniqueType(lastSon(key)) else: result = getUniqueType(lastSon(key))
of tyGenericInst, tyOrdinal, tyMutable, tyStatic: of tyGenericInst, tyOrdinal, tyStatic:
result = getUniqueType(lastSon(key)) result = getUniqueType(lastSon(key))
#let obj = lastSon(key) #let obj = lastSon(key)
#if obj.sym != nil and obj.sym.name.s == "TOption": #if obj.sym != nil and obj.sym.name.s == "TOption":
@ -153,7 +153,7 @@ proc getUniqueType*(key: PType): PType =
else: else:
# ugh, we need the canon here: # ugh, we need the canon here:
result = slowSearch(key, k) result = slowSearch(key, k)
of tyUnused, tyUnused0, tyUnused1: internalError("getUniqueType") of tyUnused, tyUnused0, tyUnused1, tyUnused2: internalError("getUniqueType")
proc tableGetType*(tab: TIdTable, key: PType): RootRef = proc tableGetType*(tab: TIdTable, key: PType): RootRef =
# returns nil if we need to declare this type # returns nil if we need to declare this type

5
compiler/jsgen.nim
View file

@ -151,8 +151,7 @@ proc mapType(typ: PType): TJSTypeKind =
of tyPointer: of tyPointer:
# treat a tyPointer like a typed pointer to an array of bytes # treat a tyPointer like a typed pointer to an array of bytes
result = etyBaseIndex result = etyBaseIndex
of tyRange, tyDistinct, tyOrdinal, tyMutable, tyProxy: of tyRange, tyDistinct, tyOrdinal, tyProxy: result = mapType(t.sons[0])
result = mapType(t.sons[0])
of tyInt..tyInt64, tyUInt..tyUInt64, tyEnum, tyChar: result = etyInt of tyInt..tyInt64, tyUInt..tyUInt64, tyEnum, tyChar: result = etyInt
of tyBool: result = etyBool of tyBool: result = etyBool
of tyFloat..tyFloat128: result = etyFloat of tyFloat..tyFloat128: result = etyFloat
@ -170,7 +169,7 @@ proc mapType(typ: PType): TJSTypeKind =
else: result = etyNone else: result = etyNone
of tyProc: result = etyProc of tyProc: result = etyProc
of tyCString: result = etyString of tyCString: result = etyString
of tyUnused, tyUnused0, tyUnused1: internalError("mapType") of tyUnused, tyUnused0, tyUnused1, tyUnused2: internalError("mapType")
proc mapType(p: PProc; typ: PType): TJSTypeKind = proc mapType(p: PProc; typ: PType): TJSTypeKind =
if p.target == targetPHP: result = etyObject if p.target == targetPHP: result = etyObject

3
compiler/renderer.nim
View file

@ -289,8 +289,7 @@ proc lsub(n: PNode): int
proc litAux(n: PNode, x: BiggestInt, size: int): string = proc litAux(n: PNode, x: BiggestInt, size: int): string =
proc skip(t: PType): PType = proc skip(t: PType): PType =
result = t result = t
while result.kind in {tyGenericInst, tyRange, tyVar, tyDistinct, tyOrdinal, while result.kind in {tyGenericInst, tyRange, tyVar, tyDistinct, tyOrdinal}:
tyMutable}:
result = lastSon(result) result = lastSon(result)
if n.typ != nil and n.typ.skip.kind in {tyBool, tyEnum}: if n.typ != nil and n.typ.skip.kind in {tyBool, tyEnum}:
let enumfields = n.typ.skip.n let enumfields = n.typ.skip.n

4
compiler/semasgn.nim
View file

@ -223,13 +223,13 @@ proc liftBodyAux(c: var TLiftCtx; t: PType; body, x, y: PNode) =
localError(c.info, errGenerated, "cannot copy openArray") localError(c.info, errGenerated, "cannot copy openArray")
of tyFromExpr, tyProxy, tyBuiltInTypeClass, tyUserTypeClass, of tyFromExpr, tyProxy, tyBuiltInTypeClass, tyUserTypeClass,
tyUserTypeClassInst, tyCompositeTypeClass, tyAnd, tyOr, tyNot, tyAnything, tyUserTypeClassInst, tyCompositeTypeClass, tyAnd, tyOr, tyNot, tyAnything,
tyMutable, tyGenericParam, tyGenericBody, tyNil, tyExpr, tyStmt, tyGenericParam, tyGenericBody, tyNil, tyExpr, tyStmt,
tyTypeDesc, tyGenericInvocation, tyForward: tyTypeDesc, tyGenericInvocation, tyForward:
internalError(c.info, "assignment requested for type: " & typeToString(t)) internalError(c.info, "assignment requested for type: " & typeToString(t))
of tyOrdinal, tyRange, of tyOrdinal, tyRange,
tyGenericInst, tyFieldAccessor, tyStatic, tyVar: tyGenericInst, tyFieldAccessor, tyStatic, tyVar:
liftBodyAux(c, lastSon(t), body, x, y) liftBodyAux(c, lastSon(t), body, x, y)
of tyUnused, tyUnused0, tyUnused1: internalError("liftBodyAux") of tyUnused, tyUnused0, tyUnused1, tyUnused2: internalError("liftBodyAux")
proc newProcType(info: TLineInfo; owner: PSym): PType = proc newProcType(info: TLineInfo; owner: PSym): PType =
result = newType(tyProc, owner) result = newType(tyProc, owner)

2
compiler/semdestruct.nim
View file

@ -124,7 +124,7 @@ proc instantiateDestructor(c: PContext, typ: PType): PType =
# destructor that must be used for the varialbe. # destructor that must be used for the varialbe.
# The destructor is either user-defined or automatically # The destructor is either user-defined or automatically
# generated by the compiler in a member-wise fashion. # generated by the compiler in a member-wise fashion.
var t = skipTypes(typ, {tyMutable}).skipGenericAlias var t = typ.skipGenericAlias
let typeHoldingUserDefinition = if t.kind == tyGenericInst: t.base else: t let typeHoldingUserDefinition = if t.kind == tyGenericInst: t.base else: t
if typeHoldingUserDefinition.destructor != nil: if typeHoldingUserDefinition.destructor != nil:

46
compiler/types.nim
View file

@ -51,17 +51,14 @@ const
# TODO: Remove tyTypeDesc from each abstractX and (where necessary) # TODO: Remove tyTypeDesc from each abstractX and (where necessary)
# replace with typedescX # replace with typedescX
abstractPtrs* = {tyVar, tyPtr, tyRef, tyGenericInst, tyDistinct, tyOrdinal, abstractPtrs* = {tyVar, tyPtr, tyRef, tyGenericInst, tyDistinct, tyOrdinal,
tyMutable, tyTypeDesc}
abstractVar* = {tyVar, tyGenericInst, tyDistinct, tyOrdinal,
tyMutable, tyTypeDesc}
abstractRange* = {tyGenericInst, tyRange, tyDistinct, tyOrdinal,
tyMutable, tyTypeDesc}
abstractVarRange* = {tyGenericInst, tyRange, tyVar, tyDistinct, tyOrdinal,
tyMutable, tyTypeDesc}
abstractInst* = {tyGenericInst, tyDistinct, tyMutable, tyOrdinal,
tyTypeDesc} tyTypeDesc}
abstractVar* = {tyVar, tyGenericInst, tyDistinct, tyOrdinal, tyTypeDesc}
abstractRange* = {tyGenericInst, tyRange, tyDistinct, tyOrdinal, tyTypeDesc}
abstractVarRange* = {tyGenericInst, tyRange, tyVar, tyDistinct, tyOrdinal,
tyTypeDesc}
abstractInst* = {tyGenericInst, tyDistinct, tyOrdinal, tyTypeDesc}
skipPtrs* = {tyVar, tyPtr, tyRef, tyGenericInst, tyMutable, tyTypeDesc} skipPtrs* = {tyVar, tyPtr, tyRef, tyGenericInst, tyTypeDesc}
# typedescX is used if we're sure tyTypeDesc should be included (or skipped) # typedescX is used if we're sure tyTypeDesc should be included (or skipped)
typedescPtrs* = abstractPtrs + {tyTypeDesc} typedescPtrs* = abstractPtrs + {tyTypeDesc}
typedescInst* = abstractInst + {tyTypeDesc} typedescInst* = abstractInst + {tyTypeDesc}
@ -115,7 +112,7 @@ proc isFloatLit*(t: PType): bool {.inline.} =
proc isCompatibleToCString(a: PType): bool = proc isCompatibleToCString(a: PType): bool =
if a.kind == tyArray: if a.kind == tyArray:
if (firstOrd(a.sons[0]) == 0) and if (firstOrd(a.sons[0]) == 0) and
(skipTypes(a.sons[0], {tyRange, tyMutable, tyGenericInst}).kind in (skipTypes(a.sons[0], {tyRange, tyGenericInst}).kind in
{tyInt..tyInt64, tyUInt..tyUInt64}) and {tyInt..tyInt64, tyUInt..tyUInt64}) and
(a.sons[1].kind == tyChar): (a.sons[1].kind == tyChar):
result = true result = true
@ -149,12 +146,12 @@ proc isOrdinalType(t: PType): bool =
const const
# caution: uint, uint64 are no ordinal types! # caution: uint, uint64 are no ordinal types!
baseKinds = {tyChar,tyInt..tyInt64,tyUInt8..tyUInt32,tyBool,tyEnum} baseKinds = {tyChar,tyInt..tyInt64,tyUInt8..tyUInt32,tyBool,tyEnum}
parentKinds = {tyRange, tyOrdinal, tyMutable, tyGenericInst, tyDistinct} parentKinds = {tyRange, tyOrdinal, tyGenericInst, tyDistinct}
t.kind in baseKinds or (t.kind in parentKinds and isOrdinalType(t.sons[0])) t.kind in baseKinds or (t.kind in parentKinds and isOrdinalType(t.sons[0]))
proc enumHasHoles(t: PType): bool = proc enumHasHoles(t: PType): bool =
var b = t var b = t
while b.kind in {tyMutable, tyRange, tyGenericInst}: b = b.sons[0] while b.kind in {tyRange, tyGenericInst}: b = b.sons[0]
result = b.kind == tyEnum and tfEnumHasHoles in b.flags result = b.kind == tyEnum and tfEnumHasHoles in b.flags
proc iterOverTypeAux(marker: var IntSet, t: PType, iter: TTypeIter, proc iterOverTypeAux(marker: var IntSet, t: PType, iter: TTypeIter,
@ -272,7 +269,7 @@ proc analyseObjectWithTypeFieldAux(t: PType,
if res == frHeader: result = frHeader if res == frHeader: result = frHeader
if result == frNone: if result == frNone:
if isObjectWithTypeFieldPredicate(t): result = frHeader if isObjectWithTypeFieldPredicate(t): result = frHeader
of tyGenericInst, tyDistinct, tyMutable: of tyGenericInst, tyDistinct:
result = analyseObjectWithTypeFieldAux(lastSon(t), marker) result = analyseObjectWithTypeFieldAux(lastSon(t), marker)
of tyArray, tyArrayConstr, tyTuple: of tyArray, tyArrayConstr, tyTuple:
for i in countup(0, sonsLen(t) - 1): for i in countup(0, sonsLen(t) - 1):
@ -405,8 +402,8 @@ const
"int", "int8", "int16", "int32", "int64", "int", "int8", "int16", "int32", "int64",
"float", "float32", "float64", "float128", "float", "float32", "float64", "float128",
"uint", "uint8", "uint16", "uint32", "uint64", "uint", "uint8", "uint16", "uint32", "uint64",
"bignum", "const ", "unused0", "unused1",
"!", "varargs[$1]", "iter[$1]", "Error Type", "unused2", "varargs[$1]", "unused", "Error Type",
"BuiltInTypeClass", "UserTypeClass", "BuiltInTypeClass", "UserTypeClass",
"UserTypeClassInst", "CompositeTypeClass", "UserTypeClassInst", "CompositeTypeClass",
"and", "or", "not", "any", "static", "TypeFromExpr", "FieldAccessor", "and", "or", "not", "any", "static", "TypeFromExpr", "FieldAccessor",
@ -531,7 +528,7 @@ proc typeToString(typ: PType, prefer: TPreferedDesc = preferName): string =
add(result, typeToString(t.sons[i])) add(result, typeToString(t.sons[i]))
if i < sonsLen(t) - 1: add(result, ", ") if i < sonsLen(t) - 1: add(result, ", ")
add(result, ')') add(result, ')')
of tyPtr, tyRef, tyVar, tyMutable: of tyPtr, tyRef, tyVar:
result = typeToStr[t.kind] result = typeToStr[t.kind]
if t.len >= 2: if t.len >= 2:
setLen(result, result.len-1) setLen(result, result.len-1)
@ -603,7 +600,7 @@ proc firstOrd(t: PType): BiggestInt =
else: else:
assert(t.n.sons[0].kind == nkSym) assert(t.n.sons[0].kind == nkSym)
result = t.n.sons[0].sym.position result = t.n.sons[0].sym.position
of tyGenericInst, tyDistinct, tyMutable, tyTypeDesc, tyFieldAccessor: of tyGenericInst, tyDistinct, tyTypeDesc, tyFieldAccessor:
result = firstOrd(lastSon(t)) result = firstOrd(lastSon(t))
of tyOrdinal: of tyOrdinal:
if t.len > 0: result = firstOrd(lastSon(t)) if t.len > 0: result = firstOrd(lastSon(t))
@ -639,7 +636,7 @@ proc lastOrd(t: PType): BiggestInt =
of tyEnum: of tyEnum:
assert(t.n.sons[sonsLen(t.n) - 1].kind == nkSym) assert(t.n.sons[sonsLen(t.n) - 1].kind == nkSym)
result = t.n.sons[sonsLen(t.n) - 1].sym.position result = t.n.sons[sonsLen(t.n) - 1].sym.position
of tyGenericInst, tyDistinct, tyMutable, tyTypeDesc, tyFieldAccessor: of tyGenericInst, tyDistinct, tyTypeDesc, tyFieldAccessor:
result = lastOrd(lastSon(t)) result = lastOrd(lastSon(t))
of tyProxy: result = 0 of tyProxy: result = 0
of tyOrdinal: of tyOrdinal:
@ -652,7 +649,7 @@ proc lastOrd(t: PType): BiggestInt =
proc lengthOrd(t: PType): BiggestInt = proc lengthOrd(t: PType): BiggestInt =
case t.kind case t.kind
of tyInt64, tyInt32, tyInt: result = lastOrd(t) of tyInt64, tyInt32, tyInt: result = lastOrd(t)
of tyDistinct, tyMutable: result = lengthOrd(t.sons[0]) of tyDistinct: result = lengthOrd(t.sons[0])
else: else:
let last = lastOrd t let last = lastOrd t
let first = firstOrd t let first = firstOrd t
@ -961,8 +958,7 @@ proc sameTypeAux(x, y: PType, c: var TSameTypeClosure): bool =
result = a.sym.position == b.sym.position result = a.sym.position == b.sym.position
of tyGenericInvocation, tyGenericBody, tySequence, of tyGenericInvocation, tyGenericBody, tySequence,
tyOpenArray, tySet, tyRef, tyPtr, tyVar, tyArrayConstr, tyOpenArray, tySet, tyRef, tyPtr, tyVar, tyArrayConstr,
tyArray, tyProc, tyMutable, tyVarargs, tyArray, tyProc, tyVarargs, tyOrdinal, tyTypeClasses, tyFieldAccessor:
tyOrdinal, tyTypeClasses, tyFieldAccessor:
cycleCheck() cycleCheck()
if a.kind == tyUserTypeClass and a.n != nil: return a.n == b.n if a.kind == tyUserTypeClass and a.n != nil: return a.n == b.n
result = sameChildrenAux(a, b, c) and sameFlags(a, b) result = sameChildrenAux(a, b, c) and sameFlags(a, b)
@ -976,7 +972,7 @@ proc sameTypeAux(x, y: PType, c: var TSameTypeClosure): bool =
sameValue(a.n.sons[1], b.n.sons[1]) sameValue(a.n.sons[1], b.n.sons[1])
of tyGenericInst: discard of tyGenericInst: discard
of tyNone: result = false of tyNone: result = false
of tyUnused, tyUnused0, tyUnused1: internalError("sameFlags") of tyUnused, tyUnused0, tyUnused1, tyUnused2: internalError("sameFlags")
proc sameBackendType*(x, y: PType): bool = proc sameBackendType*(x, y: PType): bool =
var c = initSameTypeClosure() var c = initSameTypeClosure()
@ -1140,7 +1136,7 @@ proc typeAllowedAux(marker: var IntSet, typ: PType, kind: TSymKind,
else: result = typeAllowedAux(marker, t.lastSon, skVar, flags+{taHeap}) else: result = typeAllowedAux(marker, t.lastSon, skVar, flags+{taHeap})
of tyPtr: of tyPtr:
result = typeAllowedAux(marker, t.lastSon, skVar, flags+{taHeap}) result = typeAllowedAux(marker, t.lastSon, skVar, flags+{taHeap})
of tyArrayConstr, tySet, tyMutable: of tyArrayConstr, tySet:
for i in countup(0, sonsLen(t) - 1): for i in countup(0, sonsLen(t) - 1):
result = typeAllowedAux(marker, t.sons[i], kind, flags) result = typeAllowedAux(marker, t.sons[i], kind, flags)
if result != nil: break if result != nil: break
@ -1157,7 +1153,7 @@ proc typeAllowedAux(marker: var IntSet, typ: PType, kind: TSymKind,
# for now same as error node; we say it's a valid type as it should # for now same as error node; we say it's a valid type as it should
# prevent cascading errors: # prevent cascading errors:
result = nil result = nil
of tyUnused, tyUnused0, tyUnused1: internalError("typeAllowedAux") of tyUnused, tyUnused0, tyUnused1, tyUnused2: internalError("typeAllowedAux")
proc typeAllowed*(t: PType, kind: TSymKind): PType = proc typeAllowed*(t: PType, kind: TSymKind): PType =
# returns 'nil' on success and otherwise the part of the type that is # returns 'nil' on success and otherwise the part of the type that is
@ -1308,7 +1304,7 @@ proc computeSizeAux(typ: PType, a: var BiggestInt): BiggestInt =
if result < 0: return if result < 0: return
if a < maxAlign: a = maxAlign if a < maxAlign: a = maxAlign
result = align(result, a) result = align(result, a)
of tyGenericInst, tyDistinct, tyGenericBody, tyMutable: of tyGenericInst, tyDistinct, tyGenericBody:
result = computeSizeAux(lastSon(typ), a) result = computeSizeAux(lastSon(typ), a)
of tyTypeDesc: of tyTypeDesc:
result = computeSizeAux(typ.base, a) result = computeSizeAux(typ.base, a)

3
compiler/vmdeps.nim
View file

@ -266,7 +266,6 @@ proc mapTypeToAstX(t: PType; info: TLineInfo;
of tyUInt16: result = atomicType("uint16", mUint16) of tyUInt16: result = atomicType("uint16", mUint16)
of tyUInt32: result = atomicType("uint32", mUint32) of tyUInt32: result = atomicType("uint32", mUint32)
of tyUInt64: result = atomicType("uint64", mUint64) of tyUInt64: result = atomicType("uint64", mUint64)
of tyMutable: result = mapTypeToBracket("mutable", mNone, t, info)
of tyVarargs: result = mapTypeToBracket("varargs", mVarargs, t, info) of tyVarargs: result = mapTypeToBracket("varargs", mVarargs, t, info)
of tyProxy: result = atomicType("error", mNone) of tyProxy: result = atomicType("error", mNone)
of tyBuiltInTypeClass: of tyBuiltInTypeClass:
@ -289,7 +288,7 @@ proc mapTypeToAstX(t: PType; info: TLineInfo;
result.add atomicType("static", mNone) result.add atomicType("static", mNone)
if t.n != nil: if t.n != nil:
result.add t.n.copyTree result.add t.n.copyTree
of tyUnused, tyUnused0, tyUnused1: internalError("mapTypeToAstX") of tyUnused, tyUnused0, tyUnused1, tyUnused2: internalError("mapTypeToAstX")
proc opMapTypeToAst*(t: PType; info: TLineInfo): PNode = proc opMapTypeToAst*(t: PType; info: TLineInfo): PNode =
result = mapTypeToAstX(t, info, false, true) result = mapTypeToAstX(t, info, false, true)

4
lib/core/macros.nim
View file

@ -90,8 +90,8 @@ type
ntyInt8, ntyInt16, ntyInt32, ntyInt64, ntyInt8, ntyInt16, ntyInt32, ntyInt64,
ntyFloat, ntyFloat32, ntyFloat64, ntyFloat128, ntyFloat, ntyFloat32, ntyFloat64, ntyFloat128,
ntyUInt, ntyUInt8, ntyUInt16, ntyUInt32, ntyUInt64, ntyUInt, ntyUInt8, ntyUInt16, ntyUInt32, ntyUInt64,
ntyUnused0, ntyUnused0, ntyUnused1, ntyUnused2,
ntyUnused1, ntyMutable, ntyVarargs, ntyVarargs,
ntyUnused, ntyUnused,
ntyError, ntyError,
ntyBuiltinTypeClass, ntyConcept, ntyConceptInst, ntyComposite, ntyBuiltinTypeClass, ntyConcept, ntyConceptInst, ntyComposite,