updated the compiler to use the new symbol names

compiler/semasgn.nim

@@ -0,0 +1,196 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2014 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## This module implements lifting for assignments and ``deepCopy``.
+
+# included from sem.nim
+
+type
+  TLiftCtx = object
+    c: PContext
+    info: TLineInfo # for construction
+    result: PNode
+    kind: TTypeAttachedOp
+
+type
+  TFieldInstCtx = object  # either 'tup[i]' or 'field' is valid
+    tupleType: PType      # if != nil we're traversing a tuple
+    tupleIndex: int
+    field: PSym
+    replaceByFieldName: bool
+
+proc instFieldLoopBody(c: TFieldInstCtx, n: PNode, forLoop: PNode): PNode =
+  case n.kind
+  of nkEmpty..pred(nkIdent), succ(nkIdent)..nkNilLit: result = n
+  of nkIdent:
+    result = n
+    var L = sonsLen(forLoop)
+    if c.replaceByFieldName:
+      if n.ident.id == forLoop[0].ident.id:
+        let fieldName = if c.tupleType.isNil: c.field.name.s
+                        elif c.tupleType.n.isNil: "Field" & $c.tupleIndex
+                        else: c.tupleType.n.sons[c.tupleIndex].sym.name.s
+        result = newStrNode(nkStrLit, fieldName)
+        return
+    # other fields:
+    for i in ord(c.replaceByFieldName)..L-3:
+      if n.ident.id == forLoop[i].ident.id:
+        var call = forLoop.sons[L-2]
+        var tupl = call.sons[i+1-ord(c.replaceByFieldName)]
+        if c.field.isNil:
+          result = newNodeI(nkBracketExpr, n.info)
+          result.add(tupl)
+          result.add(newIntNode(nkIntLit, c.tupleIndex))
+        else:
+          result = newNodeI(nkDotExpr, n.info)
+          result.add(tupl)
+          result.add(newSymNode(c.field, n.info))
+        break
+  else:
+    if n.kind == nkContinueStmt:
+      localError(n.info, errGenerated,
+                 "'continue' not supported in a 'fields' loop")
+    result = copyNode(n)
+    newSons(result, sonsLen(n))
+    for i in countup(0, sonsLen(n)-1):
+      result.sons[i] = instFieldLoopBody(c, n.sons[i], forLoop)
+
+proc liftBodyObj(c: TLiftCtx; typ, x, y: PNode) =
+  case typ.kind
+  of nkSym:
+    var fc: TFieldInstCtx  # either 'tup[i]' or 'field' is valid
+    fc.field = typ.sym
+    fc.replaceByFieldName = c.m == mFieldPairs
+    openScope(c.c)
+    inc c.c.inUnrolledContext
+    let body = instFieldLoopBody(fc, lastSon(forLoop), forLoop)
+    father.add(semStmt(c.c, body))
+    dec c.c.inUnrolledContext
+    closeScope(c.c)
+  of nkNilLit: discard
+  of nkRecCase:
+    let L = forLoop.len
+    let call = forLoop.sons[L-2]
+    if call.len > 2:
+      localError(forLoop.info, errGenerated, 
+                 "parallel 'fields' iterator does not work for 'case' objects")
+      return
+    # iterate over the selector:
+    asgnForObjectFields(c, typ[0], forLoop, father)
+    # we need to generate a case statement:
+    var caseStmt = newNodeI(nkCaseStmt, c.info)
+    # generate selector:
+    var access = newNodeI(nkDotExpr, forLoop.info, 2)
+    access.sons[0] = call.sons[1]
+    access.sons[1] = newSymNode(typ.sons[0].sym, forLoop.info)
+    caseStmt.add(semExprWithType(c.c, access))
+    # copy the branches over, but replace the fields with the for loop body:
+    for i in 1 .. <typ.len:
+      var branch = copyTree(typ[i])
+      let L = branch.len
+      branch.sons[L-1] = newNodeI(nkStmtList, forLoop.info)
+      semForObjectFields(c, typ[i].lastSon, forLoop, branch[L-1])
+      caseStmt.add(branch)
+    father.add(caseStmt)
+  of nkRecList:
+    for t in items(typ): liftBodyObj(c, t, x, y)
+  else:
+    illFormedAst(typ)
+
+proc newAsgnCall(op: PSym; x, y: PNode): PNode =
+  result = newNodeI(nkCall, x.info)
+  result.add(newSymNode(op))
+  result.add x
+  result.add y
+
+proc newAsgnStmt(le, ri: PNode): PNode =
+  result = newNodeI(nkAsgn, le.info, 2)
+  result.sons[0] = le
+  result.sons[1] = ri
+
+proc newDestructorCall(op: PSym; x: PNode): PNode =
+  result = newNodeIT(nkCall, x.info, op.typ.sons[0])
+  result.add(newSymNode(op))
+  result.add x  
+
+proc newDeepCopyCall(op: PSym; x, y: PNode): PNode =
+  result = newAsgnStmt(x, newDestructorCall(op, y))
+
+proc considerOverloadedOp(c: TLiftCtx; t: PType; x, y: PNode): bool =
+  let op = t.attachedOps[c.kind]
+  if op != nil:
+    markUsed(c.info, op)
+    case c.kind
+    of attachedDestructor:
+      c.result.add newDestructorCall(op, x)
+    of attachedAsgn:
+      c.result.add newAsgnCall(op, x, y)
+    of attachedDeepCopy:
+      c.result.add newDeepCopyCall(op, x, y)
+    result = true
+
+proc defaultOp(c: TLiftCtx; t: PType; x, y: PNode) =
+  if c.kind != attachedDestructor:
+    c.result.add newAsgnStmt(x, y)
+
+proc liftBodyAux(c: TLiftCtx; t: PType; x, y: PNode) =
+  const hasAttachedOp: array[TTypeAttachedOp, TTypeIter] = [
+    (proc (t: PType, closure: PObject): bool =
+       t.attachedOp[attachedDestructor] != nil),
+    (proc (t: PType, closure: PObject): bool =
+       t.attachedOp[attachedAsgn] != nil),
+    (proc (t: PType, closure: PObject): bool =
+       t.attachedOp[attachedDeepCopy] != nil)]
+  case t.kind
+  of tyNone, tyEmpty: discard
+  of tyPointer, tySet, tyBool, tyChar, tyEnum, tyInt..tyUInt64, tyCString:
+    defaultOp(c, t, x, y)
+  of tyPtr, tyString:
+    if not considerOverloadedOp(c, t, x, y):
+      defaultOp(c, t, x, y)
+  of tyArrayConstr, tyArray, tySequence:
+    if iterOverType(lastSon(t), hasAttachedOp[c.kind], nil):
+      # generate loop and call the attached Op:
+      
+    else:
+      defaultOp(c, t, x, y)
+  of tyObject:
+    liftBodyObj(c, t.n, x, y)
+  of tyTuple:
+    liftBodyTup(c, t, x, y)
+  of tyRef:
+    # we MUST not check for acyclic here as a DAG might still share nodes:
+    
+  of tyProc:
+    if t.callConv != ccClosure or c.kind != attachedDeepCopy:
+      defaultOp(c, t, x, y)
+    else:
+      # a big problem is that we don't know the enviroment's type here, so we
+      # have to go through some indirection; we delegate this to the codegen:
+      call = newNodeI(nkCall, n.info, 2)
+      call.typ = t
+      call.sons[0] = newSymNode(createMagic("deepCopy", mDeepCopy))
+      call.sons[1] = y
+      c.result.add newAsgnStmt(x, call)
+  of tyVarargs, tyOpenArray:
+    localError(c.info, errGenerated, "cannot copy openArray")
+  of tyFromExpr, tyIter, tyProxy, tyBuiltInTypeClass, tyUserTypeClass,
+     tyUserTypeClassInst, tyCompositeTypeClass, tyAnd, tyOr, tyNot, tyAnything,
+     tyMutable, tyGenericParam, tyGenericBody, tyNil, tyExpr, tyStmt,
+     tyTypeDesc, tyGenericInvokation, tyBigNum, tyConst, tyForward:
+    internalError(c.info, "assignment requested for type: " & typeToString(t))
+  of tyDistinct, tyOrdinal, tyRange,
+     tyGenericInst, tyFieldAccessor, tyStatic, tyVar:
+    liftBodyAux(c, lastSon(t))
+
+proc liftBody(c: PContext; typ: PType; info: TLineInfo): PNode =
+  var a: TLiftCtx
+  a.info = info
+  a.result = newNodeI(nkStmtList, info)
+  liftBodyAux(a, typ)