/******************************************************************************
 * Copyright (c) 2002 - 2006 IBM Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *****************************************************************************/
/*
 * Created on Aug 22, 2005
 */
package com.ibm.wala.cast.java.translator.polyglot;

import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import polyglot.ast.ArrayAccess;
import polyglot.ast.ArrayAccessAssign;
import polyglot.ast.ArrayInit;
import polyglot.ast.ArrayTypeNode;
import polyglot.ast.Assert;
import polyglot.ast.Assign;
import polyglot.ast.Binary;
import polyglot.ast.Binary.Operator;
import polyglot.ast.Block;
import polyglot.ast.BooleanLit;
import polyglot.ast.Branch;
import polyglot.ast.Call;
import polyglot.ast.CanonicalTypeNode;
import polyglot.ast.Case;
import polyglot.ast.Cast;
import polyglot.ast.Catch;
import polyglot.ast.CharLit;
import polyglot.ast.ClassBody;
import polyglot.ast.ClassDecl;
import polyglot.ast.ClassLit;
import polyglot.ast.ClassMember;
import polyglot.ast.Conditional;
import polyglot.ast.ConstructorCall;
import polyglot.ast.ConstructorCall.Kind;
import polyglot.ast.ConstructorDecl;
import polyglot.ast.Do;
import polyglot.ast.Empty;
import polyglot.ast.Eval;
import polyglot.ast.Expr;
import polyglot.ast.Field;
import polyglot.ast.FieldAssign;
import polyglot.ast.FieldDecl;
import polyglot.ast.FloatLit;
import polyglot.ast.For;
import polyglot.ast.Formal;
import polyglot.ast.Id;
import polyglot.ast.If;
import polyglot.ast.Import;
import polyglot.ast.Initializer;
import polyglot.ast.Instanceof;
import polyglot.ast.IntLit;
import polyglot.ast.Labeled;
import polyglot.ast.Local;
import polyglot.ast.LocalAssign;
import polyglot.ast.LocalClassDecl;
import polyglot.ast.LocalDecl;
import polyglot.ast.MethodDecl;
import polyglot.ast.New;
import polyglot.ast.NewArray;
import polyglot.ast.Node;
import polyglot.ast.NodeFactory;
import polyglot.ast.NullLit;
import polyglot.ast.PackageNode;
import polyglot.ast.ProcedureDecl;
import polyglot.ast.Receiver;
import polyglot.ast.Return;
import polyglot.ast.SourceFile;
import polyglot.ast.Special;
import polyglot.ast.Stmt;
import polyglot.ast.StringLit;
import polyglot.ast.Switch;
import polyglot.ast.SwitchBlock;
import polyglot.ast.SwitchElement;
import polyglot.ast.Synchronized;
import polyglot.ast.Throw;
import polyglot.ast.TopLevelDecl;
import polyglot.ast.Try;
import polyglot.ast.Unary;
import polyglot.ast.While;
import polyglot.types.ArrayType;
import polyglot.types.ClassType;
import polyglot.types.CodeInstance;
import polyglot.types.ConstructorInstance;
import polyglot.types.Context;
import polyglot.types.FieldInstance;
import polyglot.types.Flags;
import polyglot.types.InitializerDef;
import polyglot.types.InitializerInstance;
import polyglot.types.MemberDef;
import polyglot.types.MethodInstance;
import polyglot.types.ObjectType;
import polyglot.types.ProcedureInstance;
import polyglot.types.SemanticException;
import polyglot.types.StructType;
import polyglot.types.Type;
import polyglot.types.TypeSystem;
import polyglot.types.Types;
import polyglot.util.Position;

import com.ibm.wala.cast.ir.translator.AstTranslator.InternalCAstSymbol;
import com.ibm.wala.cast.ir.translator.TranslatorToCAst;
import com.ibm.wala.cast.ir.translator.TranslatorToCAst.DoLoopTranslator;
import com.ibm.wala.cast.java.loader.Util;
import com.ibm.wala.cast.java.translator.JavaProcedureEntity;
import com.ibm.wala.cast.java.types.JavaType;
import com.ibm.wala.cast.tree.CAst;
import com.ibm.wala.cast.tree.CAstAnnotation;
import com.ibm.wala.cast.tree.CAstControlFlowMap;
import com.ibm.wala.cast.tree.CAstEntity;
import com.ibm.wala.cast.tree.CAstNode;
import com.ibm.wala.cast.tree.CAstNodeTypeMap;
import com.ibm.wala.cast.tree.CAstQualifier;
import com.ibm.wala.cast.tree.CAstSourcePositionMap;
import com.ibm.wala.cast.tree.CAstSymbol;
import com.ibm.wala.cast.tree.CAstType;
import com.ibm.wala.cast.tree.CAstTypeDictionary;
import com.ibm.wala.cast.tree.impl.AbstractSourcePosition;
import com.ibm.wala.cast.tree.impl.CAstControlFlowRecorder;
import com.ibm.wala.cast.tree.impl.CAstImpl;
import com.ibm.wala.cast.tree.impl.CAstNodeTypeMapRecorder;
import com.ibm.wala.cast.tree.impl.CAstOperator;
import com.ibm.wala.cast.tree.impl.CAstSourcePositionRecorder;
import com.ibm.wala.cast.tree.impl.CAstSymbolImpl;
import com.ibm.wala.classLoader.CallSiteReference;
import com.ibm.wala.shrikeBT.IInvokeInstruction;
import com.ibm.wala.types.ClassLoaderReference;
import com.ibm.wala.types.FieldReference;
import com.ibm.wala.types.MemberReference;
import com.ibm.wala.types.MethodReference;
import com.ibm.wala.types.Selector;
import com.ibm.wala.types.TypeName;
import com.ibm.wala.types.TypeReference;
import com.ibm.wala.util.collections.EmptyIterator;
import com.ibm.wala.util.collections.HashMapFactory;
import com.ibm.wala.util.collections.IteratorPlusOne;
import com.ibm.wala.util.collections.Pair;
import com.ibm.wala.util.debug.Assertions;

public class PolyglotJava2CAstTranslator {
  protected final CAst fFactory = new CAstImpl();

  protected final NodeFactory fNodeFactory;

  protected final TypeSystem fTypeSystem;

  protected Type fNPEType;

  protected Type fCCEType;

  protected Type fREType; // RuntimeException

  protected Type fDivByZeroType;

  protected final ClassLoaderReference fClassLoaderRef;

  private CAstTypeDictionary fTypeDict;

  private TranslatingVisitor fTranslator;

  protected PolyglotIdentityMapper fIdentityMapper;

  protected final DoLoopTranslator doLoopTranslator;
  
  protected final boolean DEBUG = true;
 
  private final Node ast;
 
  final protected TranslatingVisitor getTranslator() {
    if (fTranslator == null)
      fTranslator = createTranslator();
    return fTranslator;
  }

  protected TranslatingVisitor createTranslator() {
    return new JavaTranslatingVisitorImpl();
  }

  protected CAstTypeDictionary getTypeDict() {
    if (fTypeDict == null) {
      fTypeDict = createTypeDict();
    }
    return fTypeDict;
  }

  protected PolyglotTypeDictionary createTypeDict() {
    return new PolyglotTypeDictionary(fTypeSystem, this);
  }

  protected static CAstOperator mapUnaryOpcode(Unary.Operator operator) {
    if (operator.equals(Unary.BIT_NOT))
      return CAstOperator.OP_BITNOT;
    if (operator.equals(Unary.NEG))
      return CAstOperator.OP_SUB; // CAst will handle OP_SUB with only 1
    // arg properly !!! Hah!
    if (operator.equals(Unary.NOT))
      return CAstOperator.OP_NOT;
    if (operator.equals(Unary.POS))
      return CAstOperator.OP_ADD; // CAst will throw away OP_ADD with only
    // 1 arg!!!

    if (operator.equals(Unary.POST_DEC))
      return CAstOperator.OP_SUB; // translator will produce different
    // CAstNode types for post dec
    if (operator.equals(Unary.POST_INC))
      return CAstOperator.OP_ADD; // translator will produce different
    // CAstNode types for post inc
    if (operator.equals(Unary.PRE_DEC))
      return CAstOperator.OP_SUB; // translator will produce different
    // CAstNode types for pre dec
    if (operator.equals(Unary.PRE_INC))
      return CAstOperator.OP_ADD; // translator will produce different
    // CAstNode types for pre inc

    Assertions.UNREACHABLE("Java2CAstTranslator.JavaTranslatingVisitorImpl.mapUnaryOpcode(): unrecognized unary operator.");
    return null;
  }

  protected static CAstOperator mapBinaryOpcode(Binary.Operator operator) {
    if (operator.equals(Binary.ADD))
      return CAstOperator.OP_ADD;
    if (operator.equals(Binary.BIT_AND))
      return CAstOperator.OP_BIT_AND;
    if (operator.equals(Binary.BIT_OR))
      return CAstOperator.OP_BIT_OR;
    if (operator.equals(Binary.BIT_XOR))
      return CAstOperator.OP_BIT_XOR;
    if (operator.equals(Binary.COND_AND))
      return CAstOperator.OP_REL_AND;
    if (operator.equals(Binary.COND_OR))
      return CAstOperator.OP_REL_OR;
    if (operator.equals(Binary.DIV))
      return CAstOperator.OP_DIV;
    if (operator.equals(Binary.EQ))
      return CAstOperator.OP_EQ;
    if (operator.equals(Binary.GE))
      return CAstOperator.OP_GE;
    if (operator.equals(Binary.GT))
      return CAstOperator.OP_GT;
    if (operator.equals(Binary.LE))
      return CAstOperator.OP_LE;
    if (operator.equals(Binary.LT))
      return CAstOperator.OP_LT;
    if (operator.equals(Binary.MOD))
      return CAstOperator.OP_MOD;
    if (operator.equals(Binary.MUL))
      return CAstOperator.OP_MUL;
    if (operator.equals(Binary.NE))
      return CAstOperator.OP_NE;
    if (operator.equals(Binary.SHL))
      return CAstOperator.OP_LSH;
    if (operator.equals(Binary.SHR))
      return CAstOperator.OP_RSH;
    if (operator.equals(Binary.SUB))
      return CAstOperator.OP_SUB;
    if (operator.equals(Binary.USHR))
      return CAstOperator.OP_URSH;
    Assertions.UNREACHABLE("Java2CAstTranslator.JavaTranslatingVisitorImpl.mapBinaryOpcode(): unrecognized binary operator.");
    return null;
  }

  protected CAstNode translateConstant(Object constant) {
    return fFactory.makeConstant(constant);
  }

  protected class JavaTranslatingVisitorImpl implements TranslatingVisitor {
    public CAstNode visit(MethodDecl m, MethodContext mc) {
      if (m.body() == null || m.body().statements().size() == 0)
        return makeNode(mc, fFactory, m, CAstNode.RETURN);
      else
        return walkNodes(m.body(), mc);
    }

    public CAstNode visit(ConstructorDecl cd, MethodContext mc) {
      // Needs to examine the initializers in the ClassContext
      // and glue that code into the right place relative to the
      // constructor method body ("wherever that may turn out to be").
      List/* <FieldDecl|Initializer> */inits = mc.getInitializers();
      Block body = cd.body();

      if (hasSuperCall(body)) {
        // Split at call to super:
        // super();
        // field initializer code
        // remainder of ctor body
        CAstNode[] bodyNodes = new CAstNode[inits.size() + body.statements().size()];

        int idx = 0;
        for (Iterator iter = body.statements().iterator(); iter.hasNext();) {
          Stmt s = (Stmt) iter.next();

          bodyNodes[idx++] = walkNodes(s, mc);
          if (idx == 1) {
            Assertions.productionAssertion(isSpecialCallStmt(s, ConstructorCall.SUPER));
            idx = insertInitializers(mc, bodyNodes, false, idx);
          }
        }
        return makeNode(mc, fFactory, body, CAstNode.BLOCK_STMT, bodyNodes);
      } else if (hasThisCall(body)) {
        return walkNodes(body, mc);
      } else {
        // add explicit call to default super()
        // RMF 4/17/2009- The following search for a superClass default ctor
        // won't work if we process Object in source. In particular, the
        // superClass might be null. In that case, simply omit the explicit
        // super() call.
        ClassType superClass = (ClassType) ((ObjectType) cd.constructorDef().asInstance().container()).superClass();
        CAstNode[] bodyNodes;
        int idx= 0;
        int bodyInitsSize= inits.size() + body.statements().size();
        if (superClass != null) {
          ProcedureInstance defaultSuperCtor = findDefaultCtor(superClass);
          CallSiteReference callSiteRef = CallSiteReference.make(0, fIdentityMapper.getMethodRef(defaultSuperCtor),
              IInvokeInstruction.Dispatch.SPECIAL);
          CAstNode superCall = makeNode(mc, fFactory, cd, CAstNode.CALL,
              makeNode(mc, fFactory, cd, CAstNode.SUPER),
              fFactory.makeConstant(callSiteRef));
          bodyNodes = new CAstNode[bodyInitsSize + 1];
          bodyNodes[idx++] = superCall;
        } else { // no super class, so no super call
          bodyNodes = new CAstNode[bodyInitsSize];
        }
        idx= insertInitializers(mc, bodyNodes, false, idx);

        for (Iterator iter = body.statements().iterator(); iter.hasNext(); idx++) {
          Stmt s = (Stmt) iter.next();
          bodyNodes[idx] = walkNodes(s, mc);
        }
        return makeNode(mc, fFactory, body, CAstNode.BLOCK_STMT, bodyNodes);
      }
    }

    private ProcedureInstance findDefaultCtor(ClassType superClass) {
      List/* <ProcedureInstance> */ctors = superClass.constructors();
      for (Iterator iter = ctors.iterator(); iter.hasNext();) {
        ConstructorInstance ctor = (ConstructorInstance) iter.next();
        if (ctor.formalTypes().isEmpty())
          return ctor;
      }
      Assertions.UNREACHABLE("Couldn't find default ctor");
      return null;
    }

    public CAstNode visit(FieldDecl f, MethodContext ctorContext) {
      // Generate CAST node for the initializer (init())
      // Type targetType = f.memberInstance().container();
      // Type fieldType = f.type().type();
      FieldReference fieldRef = fIdentityMapper.getFieldRef(f.fieldDef().asInstance());
      // We use null to indicate an OBJECT_REF to a static field, as the
      // FieldReference doesn't
      // hold enough info to determine this. In this case, (unlike field ref)
      // we don't have a
      // target expr to evaluate.
      CAstNode thisNode = f.flags().flags().isStatic() ? makeNode(ctorContext, fFactory, null, CAstNode.VOID) : makeNode(ctorContext,
          fFactory, f, CAstNode.THIS);
      CAstNode lhsNode = makeNode(ctorContext, fFactory, f, CAstNode.OBJECT_REF, thisNode, fFactory.makeConstant(fieldRef));

      Expr init = f.init();
      CAstNode rhsNode;
      if (init instanceof ArrayInit) {
        rhsNode = visit((ArrayInit) init, ctorContext, f.declType());
      } else {
        rhsNode = walkNodes(init, ctorContext);
      }
      CAstNode assNode = makeNode(ctorContext, fFactory, f, CAstNode.ASSIGN, lhsNode, rhsNode);

      return assNode;
    }

    public CAstNode visit(Import i, WalkContext wc) {
      Assertions.UNREACHABLE("walkNodes.ASTTraverser.visit(Import)");
      return null;
    }

    public CAstNode visit(PackageNode p, WalkContext wc) {
      Assertions.UNREACHABLE("walkNodes.ASTTraverser.visit(PackageNode)");
      return null;
    }

    public CAstNode visit(CanonicalTypeNode ctn, WalkContext wc) {
      // We'll take care of this in its surrounding context...
      return makeNode(wc, fFactory, null, CAstNode.EMPTY);
    }

    public CAstNode visit(ArrayTypeNode ctn, WalkContext wc) {
      // We'll take care of this in its surrounding context...
      Assertions.UNREACHABLE("walkNodes.ASTTraverser.visit(CanonicalTypeNode)");
      return null;
    }

    /*
     * If we've handled all the parent cases, this should never be called --
     * visit(ArrayInit,WalkContext,Type) should be instead.
     */
    public CAstNode visit(ArrayInit ai, WalkContext wc) {
      if (((ArrayType) ai.type()).base().isNull()) {
        Assertions.productionAssertion(false, "bad type " + ai.type() + " for " + ai + " at " + ai.position());
      }

      TypeReference newTypeRef = fIdentityMapper.getTypeRef(ai.type());
      CAstNode[] eltNodes = new CAstNode[ai.elements().size() + 1];
      int idx = 0;

      eltNodes[idx++] = makeNode(wc, fFactory, ai, CAstNode.NEW, fFactory.makeConstant(newTypeRef), fFactory.makeConstant(ai
          .elements().size()));
      for (Iterator iter = ai.elements().iterator(); iter.hasNext(); idx++) {
        Expr element = (Expr) iter.next();
        if ( element instanceof ArrayInit ) {
          eltNodes[idx] = visit((ArrayInit)element, wc, ((ArrayType)ai.type()).base());
        } else {
          eltNodes[idx] = walkNodes(element, wc);
        }
        if (eltNodes[idx] == null) {
          Assertions.productionAssertion(eltNodes[idx] != null, element.toString());
        }
      }

      return makeNode(wc, fFactory, ai, CAstNode.ARRAY_LITERAL, eltNodes);
    }

    /*
     * Workaround for the null array init bug: just in case ai.type().base() is null (e.g.
     * "new Object[] {null}") we get the type from the parent (in this example, a
     * NewArray of type Object[])
     */
    public CAstNode visit(ArrayInit ai, WalkContext wc, Type t) {
      TypeReference newTypeRef = fIdentityMapper.getTypeRef(t);
      CAstNode[] eltNodes = new CAstNode[ai.elements().size() + 1];
      int idx = 0;

      eltNodes[idx++] = makeNode(wc, fFactory, ai, CAstNode.NEW, fFactory.makeConstant(newTypeRef), fFactory.makeConstant(ai
          .elements().size()));
      for (Iterator iter = ai.elements().iterator(); iter.hasNext(); idx++) {
        Expr element = (Expr) iter.next();
        if (element instanceof ArrayInit) {
          eltNodes[idx] = visit((ArrayInit) element, wc, ((ArrayType) t).base());
        } else {
          eltNodes[idx] = walkNodes(element, wc);
        }
        if (eltNodes[idx] == null) {
          Assertions.productionAssertion(eltNodes[idx] != null, element.toString());
        }
      }

      return makeNode(wc, fFactory, ai, CAstNode.ARRAY_LITERAL, eltNodes);
    }

    public CAstNode visit(ArrayAccessAssign aaa, WalkContext wc) {
      return processAssign(aaa, wc);
    }

    public CAstNode visit(FieldAssign fa, WalkContext wc) {
      return processAssign(fa, wc);
    }

    public CAstNode visit(LocalAssign la, WalkContext wc) {
      return processAssign(la, wc);
    }

    protected CAstNode processAssign(Node assign, CAstNode lhsCAstNode, Assign.Operator operator, Expr rhs, WalkContext wc) {
      if (operator == Assign.ASSIGN) {
        return makeNode(wc, fFactory, assign, CAstNode.ASSIGN, lhsCAstNode, walkNodes(rhs, wc));
      } else {
        CAstNode op =
          makeNode(wc, 
              fFactory, 
              assign, 
              CAstNode.ASSIGN_PRE_OP,
              lhsCAstNode,
              walkNodes(rhs, wc),
              mapAssignOperator(operator));

        if (rhs.type().isLongOrLess() &&
            (mapAssignOperator(operator)==CAstOperator.OP_DIV ||
             mapAssignOperator(operator)==CAstOperator.OP_MOD))
        {
          Collection excTargets = wc.getCatchTargets(fDivByZeroType);
          if (!excTargets.isEmpty()) {
            for (Iterator iterator = excTargets.iterator(); iterator.hasNext();) {
              Pair catchPair = (Pair) iterator.next();
              wc.cfg().add(op, catchPair.snd, fDivByZeroType);
            }
          } else {
            wc.cfg().add(op, 
                CAstControlFlowMap.EXCEPTION_TO_EXIT, 
                fDivByZeroType);
          }
        }

        return op;
      }
    }

    private CAstNode processAssign(Assign a, WalkContext wc) {
      Expr lhs= a.left(fNodeFactory).type(a.type()); // PORT1.7 An Assign no longer has a lhs Expr per se; but you can ask it to materialize one...
      WalkContext lvc = new AssignmentContext(wc);

      return processAssign(a, walkNodes(lhs, lvc), a.operator(), a.right(), wc);
    }

    protected CAstOperator mapAssignOperator(Assign.Operator op) {
      if (op == Assign.ADD_ASSIGN)
        return CAstOperator.OP_ADD;
      else if (op == Assign.BIT_AND_ASSIGN)
        return CAstOperator.OP_BIT_AND;
      else if (op == Assign.BIT_OR_ASSIGN)
        return CAstOperator.OP_BIT_OR;
      else if (op == Assign.BIT_XOR_ASSIGN)
        return CAstOperator.OP_BIT_XOR;
      else if (op == Assign.DIV_ASSIGN)
        return CAstOperator.OP_DIV;
      else if (op == Assign.MOD_ASSIGN)
        return CAstOperator.OP_MOD;
      else if (op == Assign.MUL_ASSIGN)
        return CAstOperator.OP_MUL;
      else if (op == Assign.SHL_ASSIGN)
        return CAstOperator.OP_LSH;
      else if (op == Assign.SHR_ASSIGN)
        return CAstOperator.OP_RSH;
      else if (op == Assign.SUB_ASSIGN)
        return CAstOperator.OP_SUB;
      else if (op == Assign.USHR_ASSIGN)
        return CAstOperator.OP_URSH;
      Assertions.UNREACHABLE("Unknown assignment operator");
      return null;
    }

    public CAstNode visit(Binary b, WalkContext wc) {
      Expr left = b.left();
      Expr right = b.right();
      Operator operator = b.operator();

      if (operator.equals(Binary.COND_AND))
        return makeNode(wc, fFactory, b, CAstNode.IF_EXPR, walkNodes(left, wc), walkNodes(right, wc), fFactory.makeConstant(false));
      else if (operator.equals(Binary.COND_OR))
        return makeNode(wc, fFactory, b, CAstNode.IF_EXPR, walkNodes(left, wc), fFactory.makeConstant(true), walkNodes(right, wc));
      else {
	Type leftType = left.type();
	Type rightType = right.type();
	if (leftType.isPrimitive() && rightType.isPrimitive()) {
	  CAstNode leftNode = walkNodes(left, wc);
	  CAstNode rightNode = walkNodes(right, wc);
	  
	  try {
	    Type result = fTypeSystem.promote(leftType, rightType);

	    if (! result.typeEquals(leftType, fTypeSystem.emptyContext())) {
	      leftNode = makeNode(wc, fFactory, b, CAstNode.CAST, fFactory.makeConstant(getTypeDict().getCAstTypeFor(result)), leftNode, fFactory.makeConstant(getTypeDict().getCAstTypeFor(leftType)));
	    }

	    if (! result.typeEquals(rightType, fTypeSystem.emptyContext())) {
	      rightNode = makeNode(wc, fFactory, b, CAstNode.CAST, fFactory.makeConstant(getTypeDict().getCAstTypeFor(result)), rightNode, fFactory.makeConstant(getTypeDict().getCAstTypeFor(rightType)));
	    }
	  } catch (SemanticException e) {

	  }

	  CAstNode op = makeNode(wc, fFactory, b, CAstNode.BINARY_EXPR, mapBinaryOpcode(operator), leftNode, rightNode);

	  if (leftType.isLongOrLess() &&
	      rightType.isLongOrLess() &&
	      (mapBinaryOpcode(operator)==CAstOperator.OP_DIV ||
	       mapBinaryOpcode(operator)==CAstOperator.OP_MOD))
	  {
	    Collection excTargets = wc.getCatchTargets(fDivByZeroType);
	    if (!excTargets.isEmpty()) {
	      for (Iterator iterator = excTargets.iterator(); 
		   iterator.hasNext();) 
	      {
		Pair catchPair = (Pair) iterator.next();
		wc.cfg().add(op, catchPair.snd, fDivByZeroType);
	      }
	    } else {
	      wc.cfg().add(op, 
			   CAstControlFlowMap.EXCEPTION_TO_EXIT, 
			   fDivByZeroType);
	    }
	  }

	  return op;
	  
	} else {
	  return makeNode(wc, fFactory, b, CAstNode.BINARY_EXPR, mapBinaryOpcode(operator), walkNodes(left, wc), walkNodes(right, wc));
	}
      }
    }

    @SuppressWarnings("unchecked")
    private void handleThrowsFromCall(ProcedureInstance procedureInstance, Node callAstNode, WalkContext wc) {
      List<Type> throwTypes = procedureInstance.throwTypes();
      for (Iterator<Type> iter = IteratorPlusOne.make(throwTypes.iterator(), fREType); iter.hasNext();) {
        Type thrownType = iter.next();
        Collection/* <Pair<Type,Node>> */catchTargets = wc.getCatchTargets(thrownType);

        for (Iterator targetIter = catchTargets.iterator(); targetIter.hasNext();) {
          Pair/* <Type,Node> */catchTarget = (Pair/* <Type,Node> */) targetIter.next();

          wc.cfg().add(callAstNode, catchTarget.snd, catchTarget.fst);
        }
      }
    }

    public CAstNode visit(Call c, WalkContext wc) {
      MethodInstance methodInstance = c.methodInstance();
      boolean isStatic = methodInstance.flags().isStatic();
      StructType methodOwner = methodInstance.container();

      if (methodOwner.isArray()) {
        List realOne = methodInstance.overrides(fTypeSystem.emptyContext());
        Assertions.productionAssertion(realOne.size() == 2, "bad array method");
        methodInstance = (MethodInstance) realOne.get(1);
        methodOwner = methodInstance.container();
      }

      if (!methodOwner.isClass()) {
        Assertions.productionAssertion(false, "owner " + methodOwner + " of " + methodInstance + " is not a class");
      }

      boolean isIntf = ((ClassType) methodOwner).flags().isInterface();
      Receiver target = c.target();
      boolean isSpecial = methodInstance.flags().isPrivate()
          || (target instanceof Special && ((Special) target).kind() == Special.SUPER);

      CAstNode[] children = new CAstNode[2 + methodInstance.formalTypes().size()]; // including
      // the
      // MethodReference
      int i = 0;

      if (!isStatic)
        children[i++] = walkNodes(target, wc);
      else
        children[i++] = makeNode(wc, fFactory, null, CAstNode.VOID);

      if (children[0] == null) {
        Assertions.productionAssertion(children[0] != null, "no receiver for " + methodInstance + " in " + wc.getEnclosingMethod());
      }

      MethodReference methodRef = fIdentityMapper.getMethodRef(methodInstance);
      int dummyPC = 0; // Just want to wrap the kind of call; the "rear end"
      // won't care about anything else...
      CallSiteReference callSiteRef;

      if (isStatic)
        callSiteRef = CallSiteReference.make(dummyPC, methodRef, IInvokeInstruction.Dispatch.STATIC);
      else if (isIntf)
        callSiteRef = CallSiteReference.make(dummyPC, methodRef, IInvokeInstruction.Dispatch.INTERFACE);
      else if (isSpecial)
        callSiteRef = CallSiteReference.make(dummyPC, methodRef, IInvokeInstruction.Dispatch.SPECIAL);
      else
        callSiteRef = CallSiteReference.make(dummyPC, methodRef, IInvokeInstruction.Dispatch.VIRTUAL);

      children[i++] = fFactory.makeConstant(callSiteRef);
      for (Iterator iter = c.arguments().iterator(); iter.hasNext();) {
        Expr arg = (Expr) iter.next();
        children[i++] = walkNodes(arg, wc);
      }

      handleThrowsFromCall(methodInstance, c, wc);

      CAstNode result = makeNode(wc, fFactory, c, CAstNode.CALL, children);
      wc.cfg().map(c, result);
      return result;
    }

    public CAstNode visit(ConstructorCall cc, WalkContext wc) {
      ConstructorInstance ctorInstance = cc.constructorInstance();
      StructType methodOwner = ctorInstance.container();
      Assertions.productionAssertion(methodOwner.isClass());
      MethodReference methodRef = fIdentityMapper.getMethodRef(ctorInstance);

      int dummyPC = 0; // Just want to wrap the kind of call; the "rear end"
      // won't care about anything else...
      CallSiteReference callSiteRef = CallSiteReference.make(dummyPC, methodRef, IInvokeInstruction.Dispatch.SPECIAL);

      CAstNode[] children = new CAstNode[1 + 1 + ctorInstance.formalTypes().size()]; // including
      // the
      // MethodReference
      int i = 0;

      CAstNode targetNode;

      targetNode = (cc.kind() == ConstructorCall.THIS) ? makeNode(wc, fFactory, cc, CAstNode.THIS) : makeNode(wc, fFactory, cc,
          CAstNode.SUPER);

      children[i++] = targetNode;
      children[i++] = fFactory.makeConstant(callSiteRef);
      for (Iterator iter = cc.arguments().iterator(); iter.hasNext();) {
        Expr arg = (Expr) iter.next();
        children[i++] = walkNodes(arg, wc);
      }

      handleThrowsFromCall(ctorInstance, cc, wc);

      CAstNode result = makeNode(wc, fFactory, cc, CAstNode.CALL, children);
      wc.cfg().map(cc, result);
      return result;
    }

    public CAstNode visit(Cast c, WalkContext wc) {
      Expr arg = c.expr();
      Type castedFrom = arg.type();
      Type castedTo = c.castType().type();

      // null can go into anything (e.g. in "((Foobar) null)" null can be assumed to be of type Foobar already) 
      if (castedFrom.isNull())
        castedFrom = castedTo;
      
      CAstNode ast = makeNode(wc, fFactory, c, CAstNode.CAST, fFactory.makeConstant(getTypeDict().getCAstTypeFor(castedTo)),
          walkNodes(arg, wc),
	  fFactory.makeConstant(getTypeDict().getCAstTypeFor(castedFrom)));

      Collection excTargets = wc.getCatchTargets(fCCEType);
      if (!excTargets.isEmpty()) {
        // connect ClassCastException exception edge to relevant catch targets
        // (presumably only one)
        for (Iterator iterator = excTargets.iterator(); iterator.hasNext();) {
          Pair catchPair = (Pair) iterator.next();
          wc.cfg().add(c, catchPair.snd, fCCEType);
        }
      } else {
        // connect exception edge to exit
        wc.cfg().add(c, CAstControlFlowMap.EXCEPTION_TO_EXIT, fCCEType);
      }

      wc.cfg().map(c, ast);
      return ast;
    }

    public CAstNode visit(Conditional c, WalkContext wc) {
      return makeNode(wc, fFactory, c, CAstNode.IF_EXPR, walkNodes(c.cond(), wc), walkNodes(c.consequent(), wc), walkNodes(c
          .alternative(), wc));
    }

    public CAstNode visit(Instanceof io, WalkContext wc) {
      return makeNode(wc, fFactory, io, CAstNode.INSTANCEOF, fFactory.makeConstant(getTypeDict().getCAstTypeFor(
          io.compareType().type())), walkNodes(io.expr(), wc));
    }

    public CAstNode visit(BooleanLit bl, WalkContext wc) {
      return fFactory.makeConstant(bl.value());
    }

    public CAstNode visit(ClassLit cl, WalkContext wc) {
      Type litType = cl.typeNode().type();
      String typeName = fIdentityMapper.typeToTypeID(litType);
      return makeNode(wc, fFactory, cl, CAstNode.TYPE_LITERAL_EXPR, fFactory.makeConstant(typeName));
    }

    public CAstNode visit(FloatLit fl, WalkContext wc) {
      return (fl.kind() == FloatLit.FLOAT) ? fFactory.makeConstant((float) fl.value()) : fFactory.makeConstant(fl.value());
    }

    public CAstNode visit(NullLit nl, WalkContext wc) {
      return fFactory.makeConstant(null);
    }

    public CAstNode visit(CharLit cl, WalkContext wc) {
      return fFactory.makeConstant(cl.value());
    }

    public CAstNode visit(IntLit il, WalkContext wc) {
      return fFactory.makeConstant((int) il.value());
    }

    public CAstNode visit(StringLit sl, WalkContext wc) {
      return fFactory.makeConstant(sl.value());
    }

    public CAstNode visit(New n, WalkContext wc) {
      CAstEntity anonClass = null;
      String newTypeNameStr;
      TypeReference newTypeRef;
      ConstructorInstance ctorInst = n.constructorInstance();
      MethodReference ctorRef = fIdentityMapper.getMethodRef(ctorInst);

      if (n.body() != null) {
        fIdentityMapper.mapLocalAnonTypeToMethod((ClassType) n.type(), wc.getEnclosingMethod());

        anonClass = walkEntity(n, wc);

        newTypeNameStr = anonClass.getType().getName();
        TypeName newTypeName = TypeName.string2TypeName(newTypeNameStr);
        Selector ctorSel = ctorRef.getSelector();
        newTypeRef = TypeReference.findOrCreate(fClassLoaderRef, newTypeName);
        ctorRef = MethodReference.findOrCreate(newTypeRef, ctorSel);
      } else {
        newTypeRef = fIdentityMapper.getTypeRef(n.type());
      }

      List/* <Expr> */args = n.arguments();
      String tmpName = "ctor temp"; // this name is an illegal Java
      // identifier

      // new nodes with an explicit enclosing argument, e.g. "outer.new Inner()". They are mostly treated the same, except in JavaCAst2IRTranslator.doNewObject
      CAstNode newNode;
      Expr enclosing = n.qualifier();
      if (enclosing != null) {
        CAstNode encNode = walkNodes(enclosing, wc);
        newNode = makeNode(wc, fFactory, n, CAstNode.NEW_ENCLOSING, fFactory.makeConstant(newTypeRef), encNode);
      }
      else 
        newNode = makeNode(wc, fFactory, n, CAstNode.NEW, fFactory.makeConstant(newTypeRef));
      // end enclosing new stuff

      if (n.body() != null)
        wc.addScopedEntity(newNode, anonClass);

      int dummyPC = 0; // Just want to wrap the kind of call; the "rear end"
      // won't care about anything else...
      CallSiteReference callSiteRef = CallSiteReference.make(dummyPC, ctorRef, IInvokeInstruction.Dispatch.SPECIAL);

      CAstNode[] argNodes = new CAstNode[args.size() + 2]; // args + recvr
      // + ctor ref

      int idx = 0;
      argNodes[idx++] = makeNode(wc, fFactory, n, CAstNode.VAR, fFactory.makeConstant(tmpName));
      argNodes[idx++] = fFactory.makeConstant(callSiteRef);
      for (Iterator iter = args.iterator(); iter.hasNext();) {
        Expr arg = (Expr) iter.next();
        argNodes[idx++] = walkNodes(arg, wc);
      }
      CAstNode callNode = makeNode(wc, fFactory, n, CAstNode.CALL, argNodes);
      wc.cfg().map(n, callNode);

      handleThrowsFromCall(ctorInst, n, wc);

      return makeNode(wc, fFactory, n, CAstNode.LOCAL_SCOPE, makeNode(wc, fFactory, n, CAstNode.BLOCK_EXPR, makeNode(wc, fFactory,
          n, CAstNode.DECL_STMT, fFactory.makeConstant(new InternalCAstSymbol(tmpName, true)), newNode), callNode, makeNode(wc,
          fFactory, n, CAstNode.VAR, fFactory.makeConstant(tmpName))));
    }

    public CAstNode visit(NewArray na, WalkContext wc) {
      Type newType = na.type();
      ArrayInit ai = na.init();
      Assertions.productionAssertion(newType.isArray());

      if (ai != null) {
        return visit(ai, wc, newType);
      } else {
        ArrayType arrayType = (ArrayType) newType;
        TypeReference arrayTypeRef = fIdentityMapper.getTypeRef(arrayType);

        List/* <Expr> */dims = na.dims();
        CAstNode[] args = new CAstNode[dims.size() + 1];

        int idx = 0;
        args[idx++] = fFactory.makeConstant(arrayTypeRef);
        for (Iterator iter = dims.iterator(); iter.hasNext();) {
          Expr dimExpr = (Expr) iter.next();
          args[idx++] = walkNodes(dimExpr, wc);
        }
        return makeNode(wc, fFactory, na, CAstNode.NEW, args);
      }
    }

    public CAstNode visit(Special s, WalkContext wc) {
      if (s.qualifier() != null) {
        Type owningType = s.qualifier().type();
        TypeReference owningTypeRef = fIdentityMapper.getTypeRef(owningType);

        return makeNode(wc, fFactory, s, s.kind() == Special.THIS ? CAstNode.THIS : CAstNode.SUPER, fFactory
            .makeConstant(owningTypeRef));
      } else {
        return makeNode(wc, fFactory, s, s.kind() == Special.THIS ? CAstNode.THIS : CAstNode.SUPER);
      }
    }

    public CAstNode visit(Unary u, WalkContext wc) {
      if (isAssignOp(u.operator())) {
        WalkContext lvc = new AssignmentContext(wc);
        if (u.operator().isPrefix())
          return makeNode(wc, fFactory, u, CAstNode.ASSIGN_PRE_OP, walkNodes(u.expr(), lvc), fFactory.makeConstant(1),
              mapUnaryOpcode(u.operator()));
        else
          return makeNode(wc, fFactory, u, CAstNode.ASSIGN_POST_OP, walkNodes(u.expr(), lvc), fFactory.makeConstant(1),
              mapUnaryOpcode(u.operator()));
      } else if (u.operator() == Unary.POS) // drop useless unary plus
        // operator
        return walkNodes(u.expr(), wc);
      else if (u.operator() == Unary.NEG) {
        CAstNode zero;
        if (u.expr().type().isLongOrLess())
          zero = fFactory.makeConstant(0L);
        else
          zero = fFactory.makeConstant(0.0);
        return makeNode(wc, fFactory, u, CAstNode.BINARY_EXPR, CAstOperator.OP_SUB, zero, walkNodes(u.expr(), wc));
      } else
        return makeNode(wc, fFactory, u, CAstNode.UNARY_EXPR, mapUnaryOpcode(u.operator()), walkNodes(u.expr(), wc));
    }

    protected boolean isAssignOp(Unary.Operator operator) {
      return operator == Unary.POST_DEC || operator == Unary.POST_INC || operator == Unary.PRE_DEC || operator == Unary.PRE_INC;
    }

    public CAstNode visit(ArrayAccess aa, WalkContext wc) {
      TypeReference eltTypeRef = fIdentityMapper.getTypeRef(aa.type());

      hookUpNPETargets(aa, wc);

      CAstNode n = makeNode(wc, fFactory, aa, CAstNode.ARRAY_REF, walkNodes(aa.array(), wc), fFactory.makeConstant(eltTypeRef),
          walkNodes(aa.index(), wc));
      
      wc.cfg().map(aa, n);
      
      return n;
    }

    protected void hookUpNPETargets(Node n, WalkContext wc) {
      Collection excTargets = wc.getCatchTargets(fNPEType);
      if (!excTargets.isEmpty()) {
        // connect NPE exception edge to relevant catch targets
        // (presumably only one)
        for (Iterator iterator = excTargets.iterator(); iterator.hasNext();) {
          Pair catchPair = (Pair) iterator.next();
          wc.cfg().add(n, catchPair.snd, fNPEType);
        }
      } else {
        // connect exception edge to exit
        wc.cfg().add(n, CAstControlFlowMap.EXCEPTION_TO_EXIT, fNPEType);
      }
    }

    public CAstNode visit(Field f, WalkContext wc) {
      Receiver target = f.target();
      Type targetType = target.type();

      if (targetType.isArray()) {
        Assertions.productionAssertion(f.name().toString().equals("length"));

        return makeNode(wc, fFactory, f, CAstNode.ARRAY_LENGTH, walkNodes(target, wc));
      }
      FieldInstance fi = f.fieldInstance();
      FieldReference fieldRef = fIdentityMapper.getFieldRef(fi);
      CAstNode targetNode = walkNodes(target, wc);

      if (fi.flags().isStatic()) {
        // JLS says: evaluate the target of the field ref and throw it away.
        // Hence the following block expr, whose 2 children are the target
        // evaluation
        // followed by the OBJECT_REF with a null target child (which the
        // "back-end"
        // CAst -> IR translator interprets as a static ref).
        if (fi.isConstant()) {
          return makeNode(wc, fFactory, f, CAstNode.BLOCK_EXPR, targetNode, // can have side effects!
              translateConstant(fi.constantValue()));
        } else {
          return makeNode(wc, fFactory, f, CAstNode.BLOCK_EXPR, targetNode, makeNode(wc, fFactory, f, CAstNode.OBJECT_REF,
              makeNode(wc, fFactory, null, CAstNode.VOID), fFactory.makeConstant(fieldRef)));
        }
      } else {
        Collection excTargets = wc.getCatchTargets(fNPEType);
        if (!excTargets.isEmpty()) {
          // connect NPE exception edge to relevant catch targets
          // (presumably only one)
          for (Iterator iterator = excTargets.iterator(); iterator.hasNext();) {
            Pair catchPair = (Pair) iterator.next();
            wc.cfg().add(f, catchPair.snd, fNPEType);
          }
        } else {
          // connect exception edge to exit
          wc.cfg().add(f, CAstControlFlowMap.EXCEPTION_TO_EXIT, fNPEType);
        }
        CAstNode refNode = makeNode(wc, fFactory, f, CAstNode.OBJECT_REF, targetNode, fFactory.makeConstant(fieldRef));

        wc.cfg().map(f, refNode);

        if (fi.isConstant()) {
          return makeNode(wc, fFactory, f, CAstNode.BLOCK_EXPR, refNode, // can have side effects!
              translateConstant(fi.constantValue()));
        } else {
          return refNode;
        }
      }
    }

    public CAstNode visit(Local l, WalkContext wc) {
      return makeNode(wc, fFactory, l, CAstNode.VAR, fFactory.makeConstant(l.name().id().toString()));
    }

    public CAstNode visit(ClassBody cb, WalkContext wc) {
      Assertions.UNREACHABLE("walkNodes.ASTTraverser.visit(ClassBody)");
      return null;
    }

    public CAstNode visit(ClassDecl cd, WalkContext wc) {
      Assertions.UNREACHABLE("walkNodes.ASTTraverser.visit(ClassDecl)");
      return null;
    }

    public CAstNode visit(Initializer i, WalkContext wc) {
      // Perhaps this is invoked from within the ConstructorDecl visit()
      // method...
      return walkNodes(i.body(), wc);
    }

    public CAstNode visit(Assert a, WalkContext wc) {
      return PolyglotJava2CAstTranslator.this.makeNode(wc, fFactory, a, CAstNode.ASSERT, walkNodes(a.cond(), wc));
    }

    public CAstNode visit(Branch b, WalkContext wc) {
      Node target = null;
      Id labelNode = b.labelNode();
      String labelStr = labelNode != null ? labelNode.id().toString() : null;
      if (b.kind() == Branch.BREAK) {
        target = wc.getBreakFor(labelStr);
      } else {
        target = wc.getContinueFor(labelStr);
      }

      Assertions.productionAssertion(target != null);

      CAstNode result = makeNode(wc, fFactory, b, CAstNode.GOTO);

      wc.cfg().map(b, result);
      wc.cfg().add(b, target, null);

      return result;
    }

    public CAstNode visit(Block b, WalkContext wc) {
      CAstNode[] stmtNodes = new CAstNode[b.statements().size()];

      int idx = 0;
      for (Iterator iter = b.statements().iterator(); iter.hasNext(); idx++) {
        Stmt s = (Stmt) iter.next();
        stmtNodes[idx] = walkNodes(s, wc);
      }
      return makeNode(wc, fFactory, b, CAstNode.LOCAL_SCOPE, makeNode(wc, fFactory, b, CAstNode.BLOCK_STMT, stmtNodes));
    }

    public CAstNode visit(SwitchBlock sb, WalkContext wc) {
      CAstNode[] stmtNodes = new CAstNode[sb.statements().size()];

      int idx = 0;
      for (Iterator iter = sb.statements().iterator(); iter.hasNext(); idx++) {
        Stmt s = (Stmt) iter.next();
        stmtNodes[idx] = walkNodes(s, wc);
      }
      return makeNode(wc, fFactory, sb, CAstNode.BLOCK_STMT, stmtNodes);
    }

    public CAstNode visit(Catch c, WalkContext wc) {
      Block body = c.body();
      Formal f = c.formal();

      CAstNode excDecl = makeNode(wc, fFactory, c, CAstNode.CATCH, fFactory.makeConstant(f.name().id().toString()), walkNodes(body, wc));
      CAstNode localScope = makeNode(wc, fFactory, c, CAstNode.LOCAL_SCOPE, excDecl);

      wc.cfg().map(c, excDecl);
      wc.getNodeTypeMap().add(excDecl, wc.getTypeDictionary().getCAstTypeFor(c.catchType()));
      return localScope;
    }

    public CAstNode visit(If i, WalkContext wc) {
      return makeNode(wc, fFactory, i, CAstNode.IF_STMT, walkNodes(i.cond(), wc), walkNodes(i.consequent(), wc), walkNodes(i
          .alternative(), wc));
    }

    public CAstNode visit(Labeled l, WalkContext wc) {
      Node breakTarget = makeBreakTarget(l);

      Node stmt = l.statement();
      while (stmt instanceof Block) {
        stmt = (Node) ((Block) stmt).statements().iterator().next();
      }

      wc.getLabelMap().put(stmt, l.labelNode().id().toString());

      CAstNode result;
      if (! (l.statement() instanceof Empty)) {
	WalkContext child = new BreakContext(wc, l.labelNode().id().toString(), breakTarget);

	result = 
	  makeNode(wc, fFactory, l, CAstNode.BLOCK_STMT, 
	    makeNode(wc, fFactory, l, CAstNode.LABEL_STMT, fFactory.makeConstant(l.labelNode().id().toString()), walkNodes(l.statement(), child)),
	    walkNodes(breakTarget, wc));
      } else {
	result = 
	  makeNode(wc, fFactory, l, CAstNode.LABEL_STMT, fFactory.makeConstant(l.labelNode().id().toString()), walkNodes(l.statement(), wc));
      }

      wc.cfg().map(l, result);

      wc.getLabelMap().remove(stmt);

      return result;
    }

    public CAstNode visit(LocalClassDecl lcd, WalkContext wc) {
      fIdentityMapper.mapLocalAnonTypeToMethod(lcd.decl().classDef().asType(), wc.getEnclosingMethod());

      CAstEntity classEntity = walkEntity(lcd.decl(), wc);

      final CAstNode lcdNode = makeNode(wc, fFactory, lcd, CAstNode.EMPTY);

      wc.addScopedEntity(lcdNode, classEntity);
      return lcdNode;
    }

    protected Node makeBreakTarget(Node loop) {
      return fNodeFactory.Labeled(Position.COMPILER_GENERATED,
              fNodeFactory.Id(Position.COMPILER_GENERATED, "breakLabel" + loop.position().toString().replace('.', '_')),
              fNodeFactory.Empty(Position.COMPILER_GENERATED));
    }

    protected Node makeContinueTarget(Node loop) {
      return fNodeFactory.Labeled(Position.COMPILER_GENERATED,
              fNodeFactory.Id(Position.COMPILER_GENERATED, "continueLabel" + loop.position().toString().replace('.', '_')),
          fNodeFactory.Empty(Position.COMPILER_GENERATED));
    }

    public CAstNode visit(Do d, WalkContext wc) {
      Node breakTarget = makeBreakTarget(d);
      Node continueTarget = makeContinueTarget(d);

      String loopLabel = (String) wc.getLabelMap().get(d);

      CAstNode continueNode = walkNodes(continueTarget, wc);
      CAstNode breakNode = walkNodes(breakTarget, wc);

      
      WalkContext lc = new LoopContext(wc, loopLabel, breakTarget, continueTarget);
      CAstNode loopExpr = walkNodes(d.cond(), wc);
      CAstNode loopBody = walkNodes(d.body(), lc);
 
      return doLoopTranslator.translateDoLoop(loopExpr, loopBody, continueNode, breakNode, wc);
    }

    
    public CAstNode visit(For f, WalkContext wc) {
      Node breakTarget = makeBreakTarget(f);
      Node continueTarget = makeContinueTarget(f);
      String loopLabel = (String) wc.getLabelMap().get(f);
      WalkContext lc = new LoopContext(wc, loopLabel, breakTarget, continueTarget);

      CAstNode[] inits = new CAstNode[f.inits().size()];
      for (int i = 0; i < inits.length; i++) {
        inits[i] = walkNodes((Node) f.inits().get(i), wc);
      }

      CAstNode[] iters = new CAstNode[f.iters().size()];
      for (int i = 0; i < iters.length; i++) {
        iters[i] = walkNodes((Node) f.iters().get(i), wc);
      }

      CAstNode initsBlock = makeNode(wc, fFactory, f, CAstNode.BLOCK_STMT, inits);
      CAstNode itersBlock = makeNode(wc, fFactory, f, CAstNode.BLOCK_STMT, iters);

      return makeNode(wc, fFactory, f, CAstNode.BLOCK_STMT, initsBlock, makeNode(wc, fFactory, f, CAstNode.LOOP, walkNodes(
          f.cond(), wc), makeNode(wc, fFactory, f, CAstNode.BLOCK_STMT, walkNodes(f.body(), lc), walkNodes(continueTarget, wc),
          itersBlock)), walkNodes(breakTarget, wc));

    }

    public CAstNode visit(While w, WalkContext wc) {
      Expr c = w.cond();
      Stmt b = w.body();

      Node breakTarget = makeBreakTarget(w);
      Node continueTarget = makeContinueTarget(w);
      String loopLabel = (String) wc.getLabelMap().get(w);
      LoopContext lc = new LoopContext(wc, loopLabel, breakTarget, continueTarget);

      /*
       * The following loop is created sligtly differently than in jscore. It doesn't have a specific target for continue.
       */
      return makeNode(wc, fFactory, w, CAstNode.BLOCK_STMT, makeNode(wc, fFactory, w, CAstNode.LOOP, walkNodes(c, wc), makeNode(wc,
          fFactory, w, CAstNode.BLOCK_STMT, walkNodes(b, lc), walkNodes(continueTarget, wc))), walkNodes(breakTarget, wc));
    }

    public CAstNode visit(Switch s, WalkContext wc) {
	Node breakLabel = fNodeFactory.Labeled(s.position(),
	        fNodeFactory.Id(s.position(), "switchBreakLabel" + s.position().toString().replace('.', '_')),
	        fNodeFactory.Empty(s.position()));
      CAstNode breakAst = walkNodes(breakLabel, wc);
      String loopLabel = (String) wc.getLabelMap().get(s);
      WalkContext child = new BreakContext(wc, loopLabel, breakLabel);
      Expr cond = s.expr();
      List cases = s.elements();

      // First compute the control flow edges for the various case labels
      for (int i = 0; i < cases.size(); i++) {
        SwitchElement se = (SwitchElement) cases.get(i);
        if (se instanceof Case) {
          Case c = (Case) se;

          if (c.isDefault())
            wc.cfg().add(s, c, CAstControlFlowMap.SWITCH_DEFAULT);
          else
            wc.cfg().add(s, c, fFactory.makeConstant(c.value()));
        }
      }
      CAstNode[] caseNodes = new CAstNode[cases.size()];

      // Now produce the CAst representation for each case
      int idx = 0;
      for (Iterator iter = cases.iterator(); iter.hasNext(); idx++) {
        SwitchElement se = (SwitchElement) iter.next();

        caseNodes[idx] = walkNodes(se, child);
      }

      // Now produce the switch stmt itself
      CAstNode switchAst = makeNode(wc, fFactory, s, CAstNode.SWITCH, walkNodes(cond, wc), makeNode(wc, fFactory, s,
          CAstNode.BLOCK_STMT, caseNodes));

      wc.cfg().map(s, switchAst);

      // Finally, wrap the entire switch in a block so that we have a
      // well-defined place to 'break' to.
      return makeNode(wc, fFactory, s, CAstNode.BLOCK_STMT, switchAst, breakAst);
    }

    public CAstNode visit(Synchronized s, WalkContext wc) {
      CAstNode exprNode = walkNodes(s.expr(), wc);
      String exprName = fFactory.makeUnique();
      CAstNode declStmt = makeNode(wc, fFactory, s, CAstNode.DECL_STMT, fFactory.makeConstant(new CAstSymbolImpl(exprName, true)),
          exprNode);
      CAstNode monitorEnterNode = makeNode(wc, fFactory, s, CAstNode.MONITOR_ENTER, makeNode(wc, fFactory, s, CAstNode.VAR,
          fFactory.makeConstant(exprName)));
      CAstNode bodyNodes = walkNodes(s.body(), wc);
      CAstNode monitorExitNode = makeNode(wc, fFactory, s, CAstNode.MONITOR_EXIT, makeNode(wc, fFactory, s, CAstNode.VAR, fFactory
          .makeConstant(exprName)));
      CAstNode tryBody = makeNode(wc, fFactory, s, CAstNode.BLOCK_STMT, monitorEnterNode, bodyNodes);
      CAstNode bigBody = makeNode(wc, fFactory, s, CAstNode.UNWIND, tryBody, monitorExitNode);

      return makeNode(wc, fFactory, s, CAstNode.BLOCK_STMT, declStmt, bigBody);
    }

    public CAstNode visit(Try t, WalkContext wc) {
      List catchBlocks = t.catchBlocks();
      Block finallyBlock = t.finallyBlock();
      Block tryBlock = t.tryBlock();

      // try/finally
      if (catchBlocks.isEmpty()) {
        return makeNode(wc, fFactory, t, CAstNode.UNWIND, walkNodes(tryBlock, wc), walkNodes(finallyBlock, wc));

        // try/catch/[finally]
      } else {
        TryCatchContext tc = new TryCatchContext(wc, t, fTypeSystem.emptyContext());

        CAstNode tryNode = walkNodes(tryBlock, tc);
        for (Iterator iter = catchBlocks.iterator(); iter.hasNext();) {
          tryNode = makeNode(wc, fFactory, t, CAstNode.TRY, tryNode, walkNodes((Catch) iter.next(), wc));
        }

        // try/catch
        if (finallyBlock == null) {
          return tryNode;

          // try/catch/finally
        } else {
          return makeNode(wc, fFactory, t, CAstNode.UNWIND, tryNode, walkNodes(finallyBlock, wc));
        }
      }
    }

    public CAstNode visit(Empty e, WalkContext wc) {
      CAstNode result = makeNode(wc, fFactory, e, CAstNode.EMPTY);
      wc.cfg().map(e, result);
      return result;
    }

    public CAstNode visit(Eval e, WalkContext wc) {
      return walkNodes(e.expr(), wc);
    }

    public CAstNode visit(LocalDecl ld, WalkContext wc) {
      Expr init = ld.init();
      Type type = ld.declType();
      CAstNode initNode;
      if (init == null) {
        if (type.isLongOrLess())
          initNode = fFactory.makeConstant(0);
        else if (type.isDouble() || type.isFloat())
          initNode = fFactory.makeConstant(0.0);
        else
          initNode = fFactory.makeConstant(null);
      } else if (init instanceof ArrayInit)
        initNode = visit((ArrayInit) init, wc, type); 
      else
          initNode = walkNodes(init, wc);

      Object defaultValue;
      if (type.isLongOrLess())
        defaultValue = new Integer(0);
      else if (type.isDouble() || type.isFloat())
        defaultValue = new Double(0.0);
      else
        defaultValue = CAstSymbol.NULL_DEFAULT_VALUE;

      boolean isFinal = ld.flags().flags().isFinal();

      return makeNode(wc, fFactory, ld, CAstNode.DECL_STMT, fFactory.makeConstant(new CAstSymbolImpl(ld.name().id().toString(), isFinal,
          defaultValue)), initNode);
    }

    public CAstNode visit(Return r, WalkContext wc) {
      Expr retExpr = r.expr();
      if (retExpr == null)
        return makeNode(wc, fFactory, r, CAstNode.RETURN);
      else
        return makeNode(wc, fFactory, r, CAstNode.RETURN, walkNodes(retExpr, wc));
    }

    public CAstNode visit(Case c, WalkContext wc) {
      CAstNode label = makeNode(wc, fFactory, c, CAstNode.LABEL_STMT, fFactory.makeConstant(c.value()));

      wc.cfg().map(c, label);
      return label;
    }

    public CAstNode visit(Throw t, WalkContext wc) {
      CAstNode result = makeNode(wc, fFactory, t, CAstNode.THROW, walkNodes(t.expr(), wc));
      Type label = t.expr().type();

      wc.cfg().map(t, result);

      Collection/* <Pair<Type,Node>> */catchNodes = wc.getCatchTargets(label);

      for (Iterator iter = catchNodes.iterator(); iter.hasNext();) {
        Pair/* <Type,Node> */catchNode = (Pair/* <Type,Node> */) iter.next();

        wc.cfg().add(t, catchNode.snd, catchNode.fst);
      }

      return result;
    }

    public CAstNode visit(Formal f, WalkContext wc) {
      return makeNode(wc, fFactory, f, CAstNode.VAR, fFactory.makeConstant(f.name().id().toString()));
    }
  }

  protected static final class CompilationUnitEntity implements CAstEntity {
    private final String fName;

    private final Collection<CAstEntity> fTopLevelDecls;

    public CompilationUnitEntity(SourceFile file, List<CAstEntity> topLevelDecls) {
      fName = (file.package_() == null) ? "" : file.package_().package_().get().fullName().toString().replace('.', '/');
      fTopLevelDecls = topLevelDecls;
    }

    public int getKind() {
      return FILE_ENTITY;
    }

    public String getName() {
      return fName;
    }

    public String getSignature() {
      Assertions.UNREACHABLE();
      return null;
    }

    public String[] getArgumentNames() {
      return new String[0];
    }

    public CAstNode[] getArgumentDefaults() {
      return new CAstNode[0];
    }

    public int getArgumentCount() {
      return 0;
    }

    public Map<CAstNode, Collection<CAstEntity>> getAllScopedEntities() {
      return Collections.singletonMap(null, fTopLevelDecls);
    }

    public Iterator getScopedEntities(CAstNode construct) {
      Assertions.UNREACHABLE("CompilationUnitEntity asked for AST-related entities, but it has no AST.");
      return null;
    }

    public CAstNode getAST() {
      return null;
    }

    @Override
    public Collection<CAstAnnotation> getAnnotations() {
        return null;
    }

    public CAstControlFlowMap getControlFlow() {
      Assertions.UNREACHABLE("CompilationUnitEntity.getControlFlow()");
      return null;
    }

    public CAstSourcePositionMap getSourceMap() {
      Assertions.UNREACHABLE("CompilationUnitEntity.getSourceMap()");
      return null;
    }

    public CAstSourcePositionMap.Position getPosition() {
      return null;
    }

    public CAstNodeTypeMap getNodeTypeMap() {
      Assertions.UNREACHABLE("CompilationUnitEntity.getNodeTypeMap()");
      return null;
    }

    public Collection getQualifiers() {
      return Collections.EMPTY_LIST;
    }

    public CAstType getType() {
      Assertions.UNREACHABLE("CompilationUnitEntity.getType()");
      return null;
    }
  }

  public class PolyglotJavaType implements JavaType {
    protected final CAstTypeDictionary fDict;

    protected final TypeSystem fSystem;

    protected final ClassType fType;

    private Collection<CAstType> fSuperTypes = null;

    public PolyglotJavaType(ClassType type, CAstTypeDictionary dict, TypeSystem system) {
      super();
      fDict = dict;
      fSystem = system;
      fType = type;
    }

    public String getName() {
      // TODO Will the IdentityMapper do the right thing for anonymous classes?
      // If so, we can delete most of the following logic...
      if (fType.isLocal() || fType.isAnonymous()) {
        return fIdentityMapper.anonLocalTypeToTypeID(fType);
      } else
        return fIdentityMapper.getTypeRef(fType).getName().toString();
    }

    public Collection<CAstType> getSupertypes() {
      if (fSuperTypes == null) {
        buildSuperTypes();
      }
      return fSuperTypes;
    }

    private void buildSuperTypes() {
      // TODO this is a source entity, but it might actually be the root type
      // (Object), so assume # intfs + 1
      Type superType;
      if (fType.superClass() == null && fType != fSystem.Object()) {
        superType = fSystem.Object(); // fSystem.Object() MUST be the root of the class hierarchy
      } else {
        superType = fType.superClass();
      }
      int N = fType.interfaces().size() + 1;

      fSuperTypes = new ArrayList<CAstType>(N);
      // Following assumes that no one can call getSupertypes() before we have
      // created CAstType's for every type in the program being analyzed.
      if (superType != null) {
        fSuperTypes.add(fDict.getCAstTypeFor(superType));
      }
      for (Iterator iter = fType.interfaces().iterator(); iter.hasNext(); ) {
        Type t = (Type) iter.next();
        if (t instanceof ClassType) {
          ClassType classType = (ClassType) t;
          if (classType == fSystem.Object()) {
            continue; // Skip fSystem.Object() as a super-interface; it really MUST be a class as far as WALA is concerned
          }
        }
        fSuperTypes.add(fDict.getCAstTypeFor(t));
      }
    }

    public Collection<CAstQualifier> getQualifiers() {
      return mapFlagsToQualifiers(fType.flags());
    }

    public boolean isInterface() {
      if (fType == fSystem.Object()) {
        return false; // fSystem.Object() MUST be a class, as far as WALA is concerned
      }
      return fType.flags().isInterface();
    }
  }

  protected abstract static class CodeBodyEntity implements CAstEntity {
    private final Map<CAstNode, Collection<CAstEntity>> fEntities;

    public CodeBodyEntity(Map<CAstNode, Collection<CAstEntity>> entities) {
      fEntities = new LinkedHashMap<CAstNode, Collection<CAstEntity>>(entities);
    }

    public Map<CAstNode, Collection<CAstEntity>> getAllScopedEntities() {
      return Collections.unmodifiableMap(fEntities);
    }

    public Iterator getScopedEntities(CAstNode construct) {
      if (fEntities.containsKey(construct)) {
        return (fEntities.get(construct)).iterator();
      } else {
        return EmptyIterator.instance();
      }
    }

    public String getSignature() {
      return Util.methodEntityToSelector(this).toString();
    }
  }

  protected final class ClassEntity implements CAstEntity {
    @SuppressWarnings("unused")
    private final ClassContext fContext;

    private final ClassType fCT;

    private final String fName;

    private final Collection<CAstEntity> fEntities;

    private final CAstSourcePositionMap.Position sourcePosition;

    private ClassEntity(ClassContext context, List<CAstEntity> entities, ClassDecl cd, Position p) {
      this(context, entities, cd.classDef().asType(), cd.name().id().toString(), p);
    }

    private ClassEntity(ClassContext context, List<CAstEntity> entities, ClassType ct, String name, Position p) {
      fContext = context;
      this.fEntities = entities;
      fCT = ct;
      fName = name;
      sourcePosition = makePosition(p);
    }

    public int getKind() {
      return TYPE_ENTITY;
    }

    public String getName() {
      return fName; // unqualified?
    }

    public String getSignature() {
      return "L" + fName.replace('.', '/') + ";";
    }

    public String[] getArgumentNames() {
      return new String[0];
    }

    public CAstNode[] getArgumentDefaults() {
      return new CAstNode[0];
    }

    public int getArgumentCount() {
      return 0;
    }

    public CAstNode getAST() {
      // This entity has no AST nodes, really.
      return null;
    }

    @Override
    public Collection<CAstAnnotation> getAnnotations() {
        return null;
    }

    public Map<CAstNode, Collection<CAstEntity>> getAllScopedEntities() {
      return Collections.singletonMap(null, fEntities);
    }

    public Iterator getScopedEntities(CAstNode construct) {
      Assertions.UNREACHABLE("Non-AST-bearing entity (ClassEntity) asked for scoped entities related to a given AST node");
      return null;
    }

    public CAstControlFlowMap getControlFlow() {
      // This entity has no AST nodes, really.
      return null;
    }

    public CAstSourcePositionMap getSourceMap() {
      // This entity has no AST nodes, really.
      return null;
    }

    public CAstSourcePositionMap.Position getPosition() {
      return sourcePosition;
    }

    public CAstNodeTypeMap getNodeTypeMap() {
      // This entity has no AST nodes, really.
      return new CAstNodeTypeMap() {
        public CAstType getNodeType(CAstNode node) {
          throw new UnsupportedOperationException();
        }
        
        public Collection<CAstNode> getMappedNodes() {
          throw new UnsupportedOperationException();
        }
      };
    }

    public Collection getQualifiers() {
      if (fCT == fTypeSystem.Object()) { // pretend the root of the hierarchy is always a class
        return mapFlagsToQualifiers(fCT.flags().clear(Flags.INTERFACE));
      }
      return mapFlagsToQualifiers(fCT.flags());
    }

    public CAstType getType() {
      return new PolyglotJavaType(fCT, getTypeDict(), fTypeSystem);
    }
    
    @Override
    public String toString() {
      return fCT.fullName().toString();
    }
  }

  protected final class ProcedureEntity extends CodeBodyEntity implements JavaProcedureEntity {
    private final CAstNode fPdast;

    private final TypeSystem fSystem;

    private final Type declaringType;

    private final CodeInstance fPd;

    private final MethodContext fMc;

    private final String[] argumentNames;

    public ProcedureEntity(CAstNode pdast, TypeSystem system, CodeInstance pd, Type declaringType, String[] argumentNames,
        Map<CAstNode, Collection<CAstEntity>> entities, MethodContext mc) {
      super(entities);
      fPdast = pdast;
      fSystem = system;
      fPd = pd;
      this.declaringType = declaringType;
      this.argumentNames = argumentNames;
      fMc = mc;
    }

    public ProcedureEntity(CAstNode pdast, TypeSystem system, CodeInstance pd, String[] argumentNames,
        Map<CAstNode, Collection<CAstEntity>> entities, MethodContext mc) {
        //PORT1.7 used to be this(pdast, system, pd, ((MemberInstance) pd).container(), argumentNames, entities, mc);
        this(pdast, system, pd, ((MemberDef) pd.def()).container().get(), argumentNames, entities, mc);
    }

    private List formalTypes() {
      if (fPd instanceof ProcedureInstance) {
        return ((ProcedureInstance) fPd).formalTypes();
      } else {
        return Collections.EMPTY_LIST;
      }
    }

    public String toString() {
      return fPd.toString();
    }

    public int getKind() {
      return CAstEntity.FUNCTION_ENTITY;
    }

    public String getName() {
      if (fPd instanceof ConstructorInstance) {
        return MethodReference.initAtom.toString();
      } else {
        if (fPd instanceof InitializerInstance) {
          return MethodReference.clinitName.toString();
        } else {
          Assertions.productionAssertion(fPd instanceof MethodInstance);
          return ((MethodInstance) fPd).name().toString();
        }
      }
    }

    public String[] getArgumentNames() {
      return argumentNames;
    }

    public CAstNode[] getArgumentDefaults() {
      return new CAstNode[0];
    }

    private Flags getFlags() {
        // PORT1.7
        if (fPd instanceof ProcedureInstance) {
            return ((MemberDef) fPd.def()).flags();
        }
        return Flags.NONE;
    }

    private boolean isStatic() {
        // PORT1.7
        if (fPd instanceof ProcedureInstance) {
            return ((MemberDef) fPd.def()).flags().isStatic();
        } else if (fPd instanceof InitializerInstance) {
            return ((InitializerInstance) fPd).def().flags().isStatic();
        }
        return false;
    }

    public int getArgumentCount() {
      return isStatic() ? formalTypes().size() : formalTypes().size() + 1;
    }

    public CAstNode getAST() {
      return fPdast;
    }

    public CAstControlFlowMap getControlFlow() {
      return fMc.cfg();
    }

    public CAstSourcePositionMap getSourceMap() {
      return fMc.pos();
    }

    public CAstSourcePositionMap.Position getPosition() {
      return getSourceMap().getPosition(fPdast);
    }

    public CAstNodeTypeMap getNodeTypeMap() {
      return fMc.getNodeTypeMap();
    }

    public Collection getQualifiers() {
      return mapFlagsToQualifiers(getFlags());
    }

    public CAstType getType() {
      return new CAstType.Method() {
        private Collection<CAstType> fExceptionTypes = null;

        private List<CAstType> fParameterTypes = null;

        public CAstType getReturnType() {
          return fMc.getTypeDictionary().getCAstTypeFor(
              (fPd instanceof MethodInstance) ? ((MethodInstance) fPd).returnType() : fSystem.Void());
        }

        public List<CAstType> getArgumentTypes() {
          if (fParameterTypes == null) {
            final List formalTypes = formalTypes();
            fParameterTypes = new ArrayList<CAstType>(formalTypes.size());

            for (Iterator iter = formalTypes.iterator(); iter.hasNext();) {
              fParameterTypes.add(fMc.getTypeDictionary().getCAstTypeFor((Type) iter.next()));
            }
          }
          return fParameterTypes;
        }

        public String getName() {
          Assertions.UNREACHABLE("CAstType.FunctionImpl#getName() called???");
          return "?";
        }

        public Collection<CAstType> getSupertypes() {
          Assertions.UNREACHABLE("CAstType.FunctionImpl#getSupertypes() called???");
          return null;
        }

        public Collection/* <CAstType> */<CAstType> getExceptionTypes() {
          if (fExceptionTypes == null) {
            fExceptionTypes = new LinkedHashSet<CAstType>();

            if (fPd instanceof ProcedureInstance) {
              List exceptions = ((ProcedureInstance) fPd).throwTypes();

              if (exceptions != null) {
                for (Iterator iterator = exceptions.iterator(); iterator.hasNext();) {
                  Type type = (Type) iterator.next();
                  fExceptionTypes.add(fMc.getTypeDictionary().getCAstTypeFor(type));
                }
              }
            }
          }

          return fExceptionTypes;
        }

        public int getArgumentCount() {
          return formalTypes().size();
        }

        public CAstType getDeclaringType() {
          return getTypeDict().getCAstTypeFor(declaringType);
        }
      };
    }
    
    @Override
    public Collection<CAstAnnotation> getAnnotations() {
        return null;
    }
  }

  protected final class FieldEntity implements CAstEntity {
    private final FieldInstance fFI;

    private final WalkContext fContext;

    private FieldEntity(FieldDecl fd, WalkContext context) {
      super();
      fFI = fd.fieldDef().asInstance();
      fContext = context;
    }

    public int getKind() {
      return CAstEntity.FIELD_ENTITY;
    }

    public String getName() {
      return fFI.name().toString();
    }

    public String getSignature() {
      return fFI.name() + fIdentityMapper.typeToTypeID(fFI.type());
    }

    public String[] getArgumentNames() {
      return new String[0];
    }

    public CAstNode[] getArgumentDefaults() {
      return new CAstNode[0];
    }

    public int getArgumentCount() {
      return 0;
    }

    public Iterator getScopedEntities(CAstNode construct) {
      return EmptyIterator.instance();
    }

    public Map<CAstNode, Collection<CAstEntity>> getAllScopedEntities() {
      return Collections.emptyMap();
    }

    public CAstNode getAST() {
      // No AST for a field decl; initializers folded into
      // constructor processing...
      return null;
    }

    @Override
    public Collection<CAstAnnotation> getAnnotations() {
        return null;
    }

    public CAstControlFlowMap getControlFlow() {
      // No AST for a field decl; initializers folded into
      // constructor processing...
      return null;
    }

    public CAstSourcePositionMap getSourceMap() {
      // No AST for a field decl; initializers folded into
      // constructor processing...
      return null;
    }

    public CAstSourcePositionMap.Position getPosition() {
      return makePosition(fFI.position());
    }

    public CAstNodeTypeMap getNodeTypeMap() {
      // No AST for a field decl; initializers folded into
      // constructor processing...
      return null;
    }

    public Collection getQualifiers() {
      return mapFlagsToQualifiers(fFI.flags());
    }

    public CAstType getType() {
      return fContext.getTypeDictionary().getCAstTypeFor(fFI.type());
    }
  }

  public interface WalkContext extends TranslatorToCAst.WalkContext<WalkContext, Node> {
    Collection<Pair<Type, Object>> getCatchTargets(Type label);

    Node getFinally();

    CodeInstance getEnclosingMethod();

    Type getEnclosingType();

    CAstTypeDictionary getTypeDictionary();

    List<ClassMember> getStaticInitializers();

    List<ClassMember> getInitializers();

    Map<Node, String> getLabelMap();

    boolean needLVal();
  }

  protected static class DelegatingContext extends TranslatorToCAst.DelegatingContext<WalkContext, Node> implements WalkContext {
    protected DelegatingContext(WalkContext parent) {
      super(parent);
    }

    public Collection<Pair<Type, Object>> getCatchTargets(Type label) {
      return parent.getCatchTargets(label);
    }

    public Node getFinally() {
      return parent.getFinally();
    }

    public CodeInstance getEnclosingMethod() {
      return parent.getEnclosingMethod();
    }

    public Type getEnclosingType() {
      return parent.getEnclosingType();
    }

    public CAstTypeDictionary getTypeDictionary() {
      return parent.getTypeDictionary();
    }

    public List<ClassMember> getStaticInitializers() {
      return parent.getStaticInitializers();
    }

    public List<ClassMember> getInitializers() {
      return parent.getInitializers();
    }

    public Map<Node, String> getLabelMap() {
      return parent.getLabelMap();
    }

    public boolean needLVal() {
      return parent.needLVal();
    }
  }

  public class ClassContext extends DelegatingContext {
    // private final ClassDecl cd;
    private final Type type;

    private List<ClassMember>/* <Initializer+FieldDecl> */fInitializers = new ArrayList<ClassMember>();

    private List<ClassMember>/* <Initializer+FieldDecl> */fStaticInitializers = new ArrayList<ClassMember>();

    private List<CAstEntity> fChildren;

    public ClassContext(Type type, List<CAstEntity> entities, WalkContext parent) {
      super(parent);
      this.type = type;
      fChildren = entities;
    }

    public void addScopedEntity(CAstNode node, CAstEntity e) {
      Assertions.productionAssertion(node == null);
      fChildren.add(e);
    }

    // public Map/*<CAstNode,CAstEntity>*/ getScopedEntities() {
    // return null; // fChildren;
    // }

    public Type getEnclosingType() {
      return type;
    }

    public List<ClassMember> getInitializers() {
      return fInitializers;
    }

    public List<ClassMember> getStaticInitializers() {
      return fStaticInitializers;
    }

    public CAstControlFlowRecorder cfg() {
      Assertions.UNREACHABLE("ClassContext.cfg()");
      return null;
    }

    public Iterator/* <Pair<Type,Node>> */getCatchTarget(Type label) {
      Assertions.UNREACHABLE("ClassContext.getCatchTarget()");
      return null;
    }

    public Node getFinally() {
      Assertions.UNREACHABLE("ClassContext.getFinally()");
      return null;
    }

    public CodeInstance getEnclosingMethod() {
      // No one outside a method defining a local class can see it,
      // so it clearly can't escape through to the method's enclosing
      // type...
      Assertions.UNREACHABLE("ClassContext.getEnclosingMethod()");
      return null;
    }

    public CAstSourcePositionRecorder pos() {
      // No AST, so no AST map
      Assertions.UNREACHABLE("ClassContext.pos()");
      return null;
    }

    public Node getContinueFor(String label) {
      Assertions.UNREACHABLE("ClassContext.getContinueFor() with label " + label + " in " + type);
      return null;
    }

    public Node getBreakFor(String label) {
      System.err.println("Cannot find break target for " + label + " in " + type);
      Assertions.UNREACHABLE("ClassContext.getBreakFor()");
      return null;
    }

    public Map<Node, String> getLabelMap() {
      Assertions.UNREACHABLE("ClassContext.getLabelMap()");
      return null;
    }

    public boolean needLVal() {
      Assertions.UNREACHABLE("ClassContext.needLVal()");
      return false;
    }
  }

  public class CodeBodyContext extends DelegatingContext {
    final CAstSourcePositionRecorder fSourceMap = new CAstSourcePositionRecorder();

    final CAstControlFlowRecorder fCFG = new CAstControlFlowRecorder(fSourceMap);

    final CAstNodeTypeMapRecorder fNodeTypeMap = new CAstNodeTypeMapRecorder();

    private final Map<Node, String> labelMap = HashMapFactory.make(2);

    private final Map<CAstNode, Collection<CAstEntity>> fEntities;

    public CodeBodyContext(WalkContext parent, Map<CAstNode, Collection<CAstEntity>> entities) {
      super(parent);
      fEntities = entities;
    }

    public CAstNodeTypeMapRecorder getNodeTypeMap() {
      return fNodeTypeMap;
    }

    public CAstSourcePositionRecorder pos() {
      return fSourceMap;
    }

    public CAstControlFlowRecorder cfg() {
      return fCFG;
    }

    public void addScopedEntity(CAstNode node, CAstEntity entity) {
      if (! fEntities.containsKey(node)) { fEntities.put(node, new HashSet<CAstEntity>(1)); }
      fEntities.get(node).add(entity);
    }

    public Map<CAstNode, Collection<CAstEntity>> getScopedEntities() {
      return fEntities;
    }

    public Map<Node, String> getLabelMap() {
      return labelMap;
    }

    public boolean needLVal() {
      return false;
    }
  }

  public class MethodContext extends CodeBodyContext {
    final CodeInstance fPI;

    public MethodContext(CodeInstance pi, Map<CAstNode, Collection<CAstEntity>> entities, WalkContext parent) {
      super(parent, entities);
      fPI = pi;
    }

    public Collection<Pair<Type, Object>> getCatchTargets(Type label) {
      Collection<Pair<Type, Object>> result = Collections.singleton(Pair.<Type,Object>make(fREType, CAstControlFlowMap.EXCEPTION_TO_EXIT));
      return result;
    }

    public CodeInstance getEnclosingMethod() {
      return fPI;
    }
  }

  private static class TryCatchContext extends DelegatingContext {
    @SuppressWarnings("unused")
    private final Try tryNode;
    
    private final Context context;

    Collection<Pair<Type,Object>> fCatchNodes = new ArrayList<Pair<Type, Object>>();

    TryCatchContext(WalkContext parent, Try tryNode, final Context context) {
      super(parent);
      this.tryNode = tryNode;
      this.context = context;   

      for (Iterator<Catch> catchIter = tryNode.catchBlocks().iterator(); catchIter.hasNext();) {
        Catch c = catchIter.next();
        Pair<Type,Object> p = Pair.make(c.catchType(), (Object)c);

        fCatchNodes.add(p);
      }
    }

    public Collection<Pair<Type, Object>> getCatchTargets(Type label) {
      // Look for all matching targets for this thrown type:
      // if supertpe match, then return only matches at this catch
      // if subtype match, then matches here and parent matches
      Collection<Pair<Type, Object>> catchNodes = new ArrayList<Pair<Type, Object>>();

      for (Iterator<Pair<Type, Object>> iter = fCatchNodes.iterator(); iter.hasNext();) {
        Pair<Type, Object> p = iter.next();
        Type catchType = p.fst;

        // _must_ be caught
        if (label.isSubtype(catchType, this.context) || label.typeEquals(catchType, this.context)) {
          catchNodes.add(p);
          return catchNodes;

          // _might_ get caught
        } else if (catchType.isSubtype(label, this.context)) {
          catchNodes.add(p);
          continue;
        }
      }
      catchNodes.addAll(parent.getCatchTargets(label));
      return catchNodes;
    }

    public List<ClassMember> getStaticInitializers() {
      return null;
    }

    public List<ClassMember> getInitializers() {
      return null;
    }
  }

  protected static class RootContext extends TranslatorToCAst.RootContext<WalkContext, Node> implements WalkContext {
    final CAstTypeDictionary fTypeDict;

    public RootContext(CAstTypeDictionary typeDict) {
      fTypeDict = typeDict;
    }

    public Collection<Pair<Type, Object>> getCatchTargets(Type label) {
      Assertions.UNREACHABLE("RootContext.getCatchTargets()");
      return null;
    }

    public Node getFinally() {
      Assertions.UNREACHABLE("RootContext.getFinally()");
      return null;
    }

    public CodeInstance getEnclosingMethod() {
      Assertions.UNREACHABLE("RootContext.getEnclosingMethod()");
      return null;
    }

    public Type getEnclosingType() {
      Assertions.UNREACHABLE("RootContext.getEnclosingType()");
      return null;
    }

    public CAstTypeDictionary getTypeDictionary() {
      return fTypeDict;
    }

    public List<ClassMember> getStaticInitializers() {
      Assertions.UNREACHABLE("RootContext.getStaticInitializers()");
      return null;
    }

    public List<ClassMember> getInitializers() {
      Assertions.UNREACHABLE("RootContext.getInitializers()");
      return null;
    }

    public Map<Node, String> getLabelMap() {
      Assertions.UNREACHABLE("RootContext.getLabelMap()");
      return null;
    }

    public boolean needLVal() {
      Assertions.UNREACHABLE("ClassContext.needLVal()");
      return false;
    }
  }

  public class BreakContext extends DelegatingContext {
    protected final String label;

    private final Node breakTo;

    BreakContext(WalkContext parent, String label, Node breakTo) {
      super(parent);
      this.label = label;
      this.breakTo = breakTo;
    }

    public Node getBreakFor(String label) {
      return (label == null || label.equals(this.label)) ? breakTo : super.getBreakFor(label);
    }

    public List<ClassMember> getStaticInitializers() {
      return null;
    }

    public List<ClassMember> getInitializers() {
      return null;
    }
  }

  public class LoopContext extends BreakContext {
    private final Node continueTo;

    public LoopContext(WalkContext parent, String label, Node breakTo, Node continueTo) {
      super(parent, label, breakTo);
      this.continueTo = continueTo;
    }

    public Node getContinueFor(String label) {
      return (label == null || label.equals(this.label)) ? continueTo : super.getContinueFor(label);
    }
  }

  private class AssignmentContext extends DelegatingContext {

    protected AssignmentContext(WalkContext parent) {
      super(parent);
    }

    public boolean needLVal() {
      return true;
    }
  }

  public PolyglotJava2CAstTranslator(Node ast, ClassLoaderReference clr, NodeFactory nf, TypeSystem ts, PolyglotIdentityMapper identityMapper, boolean replicateForDoLoops) {
    this.ast = ast;
    fClassLoaderRef = clr;
    fTypeSystem = ts;
    fNodeFactory = nf;
    fIdentityMapper = identityMapper;
    doLoopTranslator = new DoLoopTranslator(replicateForDoLoops, fFactory);
    fNPEType = fTypeSystem.NullPointerException();
    fCCEType = fTypeSystem.ClassCastException();
    fREType = fTypeSystem.RuntimeException();
    fDivByZeroType = fTypeSystem.ArithmeticException();
  }

  public static class PolyglotSourcePosition extends AbstractSourcePosition {
    private final Position p;

    public PolyglotSourcePosition(Position p) {
      this.p = p;
    }

    public int getFirstLine() {
      return p.line();
    }

    public int getLastLine() {
      return p.endLine();
    }

    public int getFirstCol() {
      return p.column();
    }

    public int getLastCol() {
      return p.endColumn();
    }
     
    public int getFirstOffset() {
      return p.offset();
    }

    public int getLastOffset() {
      return p.endOffset();
    }

    public URL getURL() {
      try {
        String path = p.path();
        return new URL("file:" + (path.length() == 0 ? p.file() : path));
      } catch (MalformedURLException e) {
        Assertions.UNREACHABLE(e.toString());
        return null;
      }
    }

    public InputStream getInputStream() throws IOException {
      return getURL().openConnection().getInputStream();
    }
  }

  protected CAstSourcePositionMap.Position makePosition(Position p) {
    return new PolyglotSourcePosition(p);
  }

  private void setPos(WalkContext wc, CAstNode cn, Node pn) {
    if (pn != null) {
      wc.pos().setPosition(cn, makePosition(pn.position()));
    }
  }

  private void setPos(WalkContext wc, CAstNode cn, Position p) {
    if (p != null) {
      wc.pos().setPosition(cn, makePosition(p));
    }
  }

  protected CAstNode makeNode(WalkContext wc, CAst Ast, Node n, int kind) {
    CAstNode cn = Ast.makeNode(kind);
    setPos(wc, cn, n);
    return cn;
  }

  protected CAstNode makeNode(WalkContext wc, CAst Ast, Node n, int kind, CAstNode c[]) {
    CAstNode cn = Ast.makeNode(kind, c);
    setPos(wc, cn, n);
    return cn;
  }

  protected CAstNode makeNode(WalkContext wc, CAst Ast, Node n, int kind, CAstNode c) {
    CAstNode cn = Ast.makeNode(kind, c);
    setPos(wc, cn, n);
    return cn;
  }

  protected CAstNode makeNode(WalkContext wc, CAst Ast, Node n, int kind, CAstNode c1, CAstNode c2) {
    CAstNode cn = Ast.makeNode(kind, c1, c2);
    setPos(wc, cn, n);
    return cn;
  }

  protected CAstNode makeNode(WalkContext wc, CAst Ast, Node n, int kind, CAstNode c1, CAstNode c2, CAstNode c3) {
    CAstNode cn = Ast.makeNode(kind, c1, c2, c3);
    setPos(wc, cn, n);
    return cn;
  }

  protected CAstNode makeNode(WalkContext wc, CAst Ast, Node n, int kind, CAstNode c1, CAstNode c2, CAstNode c3, CAstNode c4) {
    CAstNode cn = Ast.makeNode(kind, c1, c2, c3, c4);
    setPos(wc, cn, n);
    return cn;
  }

  protected CAstNode makeNode(WalkContext wc, Node n, int kind) {
    return makeNode(wc, fFactory, n, kind);
  }

  protected CAstNode makeNode(WalkContext wc, Node n, int kind, CAstNode c[]) {
    return makeNode(wc, fFactory, n, kind, c);
  }

  protected CAstNode makeNode(WalkContext wc, Node n, int kind, CAstNode c) {
    return makeNode(wc, fFactory, n, kind, c);
  }

  protected CAstNode makeNode(WalkContext wc, Node n, int kind, CAstNode c1, CAstNode c2) {
    return makeNode(wc, fFactory, n, kind, c1, c2);
  }

  protected CAstNode makeNode(WalkContext wc, Node n, int kind, CAstNode c1, CAstNode c2, CAstNode c3) {
    return makeNode(wc, fFactory, n, kind, c1, c2, c3);
  }

  protected CAstNode makeNode(WalkContext wc, Node n, int kind, CAstNode c1, CAstNode c2, CAstNode c3, CAstNode c4) {
    return makeNode(wc, fFactory, n, kind, c1, c2, c3, c4);
  }

  protected CAstNode makeNode(WalkContext wc, int kind, Position p) {
    CAstNode cn = fFactory.makeNode(kind);
    setPos(wc, cn, p);
    return cn;
  }

  protected CAstNode makeNode(WalkContext wc, Position p, int kind, CAstNode c1) {
    CAstNode cn = fFactory.makeNode(kind, c1);
    setPos(wc, cn, p);
    return cn;
  }

  protected CAstNode makeNode(WalkContext wc, Position p, int kind, CAstNode c1, CAstNode[] rest) {
    CAstNode cn = fFactory.makeNode(kind, c1, rest);
    setPos(wc, cn, p);
    return cn;
  }

  protected CAstNode makeNode(WalkContext wc, Position p, int kind, CAstNode c1, CAstNode c2) {
    CAstNode cn = fFactory.makeNode(kind, c1, c2);
    setPos(wc, cn, p);
    return cn;
  }

  protected CAstNode makeNode(WalkContext wc, Position p, int kind, CAstNode c1, CAstNode c2, CAstNode c3) {
    CAstNode cn = fFactory.makeNode(kind, c1, c2, c3);
    setPos(wc, cn, p);
    return cn;
  }

  protected CAstNode makeNode(WalkContext wc, Position p, int kind, CAstNode c1, CAstNode c2, CAstNode c3, CAstNode c4) {
    CAstNode cn = fFactory.makeNode(kind, c1, c2, c3, c4);
    setPos(wc, cn, p);
    return cn;
  }

  public CAstEntity translateToCAst() {
    return walkEntity(ast, new RootContext(getTypeDict()));
  }

  /**
   * Maps front-end-specific representations into WALA references of the appropriate kind.
   * @author rfuhrer
   *
   * @param <T> The front-end-specific representation of a type (e.g., for Polyglot, a Type)
   * @param <M> The front-end-specific representation of a procedure/method (e.g., for Polyglot, a CodeInstance)
   * @param <F> The front-end-specific representation of a field (e.g., for Polyglot, a FieldInstance)
   */
  public interface IdentityMapper<TypeRep, MethodRep, FieldRep> {
    MemberReference getMethodRef(MethodRep method);

    TypeReference getTypeRef(TypeRep type);

    FieldReference getFieldRef(FieldRep field);
  }

  protected static Collection<CAstQualifier> mapFlagsToQualifiers(Flags flags) {
    Set<CAstQualifier> quals = new LinkedHashSet<CAstQualifier>();

    if (flags.isAbstract())
      quals.add(CAstQualifier.ABSTRACT);
    if (flags.isFinal())
      quals.add(CAstQualifier.FINAL);
    if (flags.isInterface())
      quals.add(CAstQualifier.INTERFACE);
    if (flags.isNative())
      quals.add(CAstQualifier.NATIVE);
    // if (flags.isPackage()) quals.add(CAstQualifier.PACKAGE);
    if (flags.isPrivate())
      quals.add(CAstQualifier.PRIVATE);
    if (flags.isProtected())
      quals.add(CAstQualifier.PROTECTED);
    if (flags.isPublic())
      quals.add(CAstQualifier.PUBLIC);
    if (flags.isStatic())
      quals.add(CAstQualifier.STATIC);
    if (flags.isStrictFP())
      quals.add(CAstQualifier.STRICTFP);
    if (flags.isSynchronized())
      quals.add(CAstQualifier.SYNCHRONIZED);
    if (flags.isTransient())
      quals.add(CAstQualifier.TRANSIENT);
    if (flags.isVolatile())
      quals.add(CAstQualifier.VOLATILE);

    return quals;
  }

  protected void processClassMembers(Node n, ClassType classType, List<ClassMember> members, DelegatingContext classContext,
      List<CAstEntity> memberEntities) {
    // Collect all initializer-related gorp
    for (Iterator<ClassMember> memberIter = members.iterator(); memberIter.hasNext();) {
      ClassMember member = memberIter.next();

      if (member instanceof Initializer) {
        Initializer initializer = (Initializer) member;

        if (initializer.flags().flags().isStatic())
          classContext.getStaticInitializers().add(initializer);
        else
          classContext.getInitializers().add(initializer);
      } else if (member instanceof FieldDecl) {
        FieldDecl fd = (FieldDecl) member;

        if (fd.init() != null) {
          if (fd.flags().flags().isStatic())
            classContext.getStaticInitializers().add(fd);
          else
            classContext.getInitializers().add(fd);
        }
      }
    }

    // Now process
    for (Iterator<ClassMember> memberIter = members.iterator(); memberIter.hasNext();) {
      ClassMember member = memberIter.next();

      if (!(member instanceof Initializer)) {
        CAstEntity memberEntity = walkEntity(member, classContext);

        memberEntities.add(memberEntity);
      }
    }

    // add class initializer, if needed
    if (!classContext.getStaticInitializers().isEmpty()) {
        InitializerDef initDef = fTypeSystem.initializerDef(n.position(), Types.ref(classType), Flags.STATIC);
      InitializerInstance initInstance = fTypeSystem.createInitializerInstance(n.position(), Types.ref(initDef));

      Map<CAstNode, Collection<CAstEntity>> childEntities = HashMapFactory.make();
      final MethodContext mc = new MethodContext(initInstance, childEntities, classContext);

      List inits = classContext.getStaticInitializers();
      CAstNode[] bodyNodes = new CAstNode[inits.size()];
      insertInitializers(mc, bodyNodes, true, 0);

      CAstNode ast = makeNode(mc, fFactory, n, CAstNode.BLOCK_STMT, bodyNodes);

      memberEntities.add(new ProcedureEntity(ast, fTypeSystem, initInstance, new String[0], childEntities, mc));

    }
  }

  protected void addConstructorsToAnonymousClass(New n, ClassType anonType, ClassContext classContext,
      List<CAstEntity> memberEntities) {
    List superConstructors = ((ClassType) anonType.superClass()).constructors();

    for (Iterator iter = superConstructors.iterator(); iter.hasNext();) {
      ConstructorInstance superCtor = (ConstructorInstance) iter.next();

      Map<CAstNode, Collection<CAstEntity>> childEntities = HashMapFactory.make();
      final MethodContext mc = new MethodContext(superCtor, childEntities, classContext);

      String[] fakeArguments = new String[superCtor.formalTypes().size() + 1];
      for (int i = 0; i < fakeArguments.length; i++) {
        fakeArguments[i] = (i == 0) ? "this" : ("argument" + i);
      }

      List inits = classContext.getInitializers();

      CAstNode[] bodyNodes = new CAstNode[inits.size() + 1];

      CallSiteReference callSiteRef = CallSiteReference.make(0, fIdentityMapper.getMethodRef(superCtor),
          IInvokeInstruction.Dispatch.SPECIAL);
      CAstNode[] children = new CAstNode[fakeArguments.length + 1];
      children[0] = makeNode(mc, fFactory, n, CAstNode.SUPER);
      children[1] = fFactory.makeConstant(callSiteRef);
      for (int i = 1; i < fakeArguments.length; i++) {
        children[i + 1] = makeNode(mc, fFactory, n, CAstNode.VAR, fFactory.makeConstant(fakeArguments[i]));
      }
      bodyNodes[0] = makeNode(mc, fFactory, n, CAstNode.CALL, children);

      insertInitializers(mc, bodyNodes, false, 1);

      CAstNode ast = makeNode(mc, fFactory, n, CAstNode.BLOCK_STMT, bodyNodes);

      memberEntities.add(new ProcedureEntity(ast, fTypeSystem, superCtor, anonType, fakeArguments, childEntities, mc));
    }
  }

  static String anonTypeName(ClassType ct) {
    Position pos = ct.position();

    return ct.fullName() + "$" + pos.line() + "$" + pos.column();
  }

  @SuppressWarnings("unchecked")
  protected CAstEntity walkEntity(Node rootNode, final WalkContext context) {
    if (rootNode instanceof SourceFile) {
      SourceFile file = (SourceFile) rootNode;
      List<CAstEntity> declEntities = new ArrayList<CAstEntity>();

      for (Iterator iter = file.decls().iterator(); iter.hasNext();) {
        TopLevelDecl decl = (TopLevelDecl) iter.next();

        declEntities.add(walkEntity(decl, context));
      }
      return new CompilationUnitEntity(file, declEntities);
    } else if (rootNode instanceof ClassDecl) {
      final ClassDecl cd = (ClassDecl) rootNode;
      final List<CAstEntity> memberEntities = new ArrayList<CAstEntity>();
      final ClassContext classContext = new ClassContext(cd.classDef().asType(), memberEntities, context);

      processClassMembers(rootNode, cd.classDef().asType(), cd.body().members(), classContext, memberEntities);

      return new ClassEntity(classContext, memberEntities, cd, cd.position());
    } else if (rootNode instanceof New) {
      final New n = (New) rootNode;
      final List<CAstEntity> memberEntities = new ArrayList<CAstEntity>();
      ClassType anonType = (ClassType) n.anonType().asType();
      String anonTypeName = anonTypeName(anonType);
      final ClassContext classContext = new ClassContext(anonType, memberEntities, context);

      processClassMembers(rootNode, anonType, n.body().members(), classContext, memberEntities);
      addConstructorsToAnonymousClass(n, anonType, classContext, memberEntities);

      return new ClassEntity(classContext, memberEntities, anonType, anonTypeName, n.position());
    } else if (rootNode instanceof ProcedureDecl) {
      final ProcedureDecl pd = (ProcedureDecl) rootNode;
      final Map<CAstNode, Collection<CAstEntity>> memberEntities = HashMapFactory.make();
      final MethodContext mc = new MethodContext(pd.procedureInstance().asInstance(), memberEntities, context);

      CAstNode pdAST = null;

      if (!pd.flags().flags().isAbstract()) {
        // Presumably the MethodContext's parent is a ClassContext,
        // and he has the list of initializers. Hopefully the following
        // will glue that stuff in the right place in any constructor body.
        pdAST = walkNodes(pd, mc);
      }

      List/* <Formal> */formals = pd.formals();
      String[] argNames;
      int i = 0;
      if (!pd.flags().flags().isStatic()) {
        argNames = new String[formals.size() + 1];
        argNames[i++] = "this";
      } else {
        argNames = new String[formals.size()];
      }
      for (Iterator iter = formals.iterator(); iter.hasNext(); i++) {
        Formal formal = (Formal) iter.next();
        argNames[i] = formal.name().toString();
      }

      return new ProcedureEntity(pdAST, fTypeSystem, pd.procedureInstance().asInstance(), argNames, memberEntities, mc);
    } else if (rootNode instanceof FieldDecl) {
      final FieldDecl fd = (FieldDecl) rootNode;

      return new FieldEntity(fd, context);
    } else {
      Assertions.UNREACHABLE("Unknown node type for walkEntity():" + rootNode.getClass().getName());
      return null;
    }
  }

  private boolean isSpecialCallStmt(Stmt maybeSuper, Kind kind) {
    if (maybeSuper instanceof ConstructorCall) {
      ConstructorCall cc = (ConstructorCall) maybeSuper;
      return cc.kind() == kind;
    }
    return false;
  }

  private boolean hasSpecialCall(Block body, Kind kind) {
    if (body.statements().size() <= 0)
      return false;

    Stmt maybeSuper = (Stmt) body.statements().get(0);

    return isSpecialCallStmt(maybeSuper, kind);
  }

  private boolean hasSuperCall(Block body) {
    return hasSpecialCall(body, ConstructorCall.SUPER);
  }

  private boolean hasThisCall(Block body) {
    return hasSpecialCall(body, ConstructorCall.THIS);
  }

  private int insertInitializers(WalkContext wc, CAstNode[] initCode, boolean wantStatic, int offset) {
    List<ClassMember> inits = wantStatic ? wc.getStaticInitializers() : wc.getInitializers();

    for (Iterator<ClassMember> iter = inits.iterator(); iter.hasNext(); offset++) {
      ClassMember init = iter.next();
      CAstNode initNode = walkNodes(init, wc);

      if (initNode != null) {
        initCode[offset] = initNode;
      } else {
        initCode[offset] = makeNode(wc, fFactory, null, CAstNode.EMPTY);
      }
    }
    return offset;
  }

  protected CAstNode walkNodes(Node n, final WalkContext context) {
    if (n == null)
      return makeNode(context, fFactory, null, CAstNode.EMPTY);
    return ASTTraverser.visit(n, getTranslator(), context);
  }
}
