add line numbers and test

src/main/javassist/bytecode/CodeAttribute.java

             attributes.add(sm);
     }
 
+    /**
+     * Adds a line number table.  If another copy of line number table
+     * is already contained, the old one is removed.
+     *
+     * @param lnt       the line number table added to this code attribute.
+     *                  If it is null, a new line number is not added.
+     *                  Only the old line number is removed.
+     */
+    public void setAttribute(LineNumberAttribute lnt) {
+        AttributeInfo.remove(attributes, LineNumberAttribute.tag);
+        if (lnt != null)
+            attributes.add(lnt);
+    }
+
     /**
      * Copies code.
      */

src/main/javassist/bytecode/LineNumberAttribute.java

         super(cp, n, in);
     }
 
-    private LineNumberAttribute(ConstPool cp, byte[] i) {
+    LineNumberAttribute(ConstPool cp, byte[] i) {
         super(cp, tag, i);
     }
 

src/main/javassist/bytecode/LineNumberAttributeBuilder.java

+package javassist.bytecode;
+
+import javassist.compiler.ast.ASTree;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class LineNumberAttributeBuilder {
+    private final HashMap<Integer, Integer> map = new HashMap<>();
+
+    public void put(int newPc, ASTree tree) {
+        if (tree != null)
+            put(newPc, tree.getLineNumber());
+    }
+
+    private void put(int newPc, int lineNum) {
+        Integer pc = map.get(lineNum);
+        if (pc == null || newPc < pc) {
+            map.put(lineNum, newPc);
+        }
+    }
+
+    public LineNumberAttribute build(ConstPool cp) {
+        int size = map.size();
+        try (ByteArrayOutputStream bos = new ByteArrayOutputStream(size * 4 + 2);
+             DataOutputStream dos = new DataOutputStream(bos)) {
+            dos.writeShort(size);
+            for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
+                dos.writeShort(entry.getValue());
+                dos.writeShort(entry.getKey());
+            }
+            return new LineNumberAttribute(cp, bos.toByteArray());
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/javassist/compiler/CodeGen.java

         typeChecker = checker;
     }
 
-    protected static void fatal() throws CompileError {
-        throw new CompileError("fatal");
+    protected static void fatal(int lineNumber) throws CompileError {
+        throw new CompileError("fatal", lineNumber);
     }
 
     public static boolean is2word(int type, int dim) {
     }
 
     @Override
-    public void atASTList(ASTList n) throws CompileError { fatal(); }
+    public void atASTList(ASTList n) throws CompileError { fatal(n.getLineNumber()); }
 
     @Override
-    public void atPair(Pair n) throws CompileError { fatal(); }
+    public void atPair(Pair n) throws CompileError { fatal(n.getLineNumber()); }
 
     @Override
-    public void atSymbol(Symbol n) throws CompileError { fatal(); }
+    public void atSymbol(Symbol n) throws CompileError { fatal(n.getLineNumber()); }
 
     @Override
     public void atFieldDecl(FieldDecl field) throws CompileError {
                 hasReturned = true;
             }
             else
-                throw new CompileError("no return statement");
+                throw new CompileError("no return statement", s.getLineNumber());
     }
 
     private boolean needsSuperCall(Stmnt body) throws CompileError {
             // LABEL, SWITCH label stament might be null?.
             hasReturned = false;
             throw new CompileError(
-                "sorry, not supported statement: TokenId " + op);
+                "sorry, not supported statement: TokenId " + op, st.getLineNumber());
         }
     }
 
             if (op == DEFAULT)
                 defaultPc = bytecode.currentPc();
             else if (op != CASE)
-                fatal();
+                fatal(st.getLineNumber());
             else {
                 int curPos = bytecode.currentPc();
                 long caseLabel;
         expr = TypeChecker.stripPlusExpr(expr);
         if (expr instanceof IntConst)
             return (int)((IntConst)expr).get();
-        throw new CompileError("bad case label");
+        throw new CompileError("bad case label", expr.getLineNumber());
     }
 
     private int computeStringLabel(ASTree expr, int tmpVar, List<Integer> gotoDefaults)
             gotoDefaults.add(pc);
             return (int)label.hashCode();
         }
-        throw new CompileError("bad case label");
+        throw new CompileError("bad case label", expr.getLineNumber());
     }
 
     private void atBreakStmnt(Stmnt st, boolean notCont)
     {
         if (st.head() != null)
             throw new CompileError(
-                        "sorry, not support labeled break or continue");
+                        "sorry, not support labeled break or continue", st.getLineNumber());
 
         bytecode.addOpcode(Opcode.GOTO);
         Integer pc = Integer.valueOf(bytecode.currentPc());
         ASTree e = st.getLeft();
         compileExpr(e);
         if (exprType != CLASS || arrayDim > 0)
-            throw new CompileError("bad throw statement");
+            throw new CompileError("bad throw statement", st.getLineNumber());
 
         bytecode.addOpcode(ATHROW);
         hasReturned = true;
 
         compileExpr(st.head());
         if (exprType != CLASS && arrayDim == 0)
-            throw new CompileError("bad type expr for synchronized block");
+            throw new CompileError("bad type expr for synchronized block", st.getLineNumber());
 
         Bytecode bc = bytecode;
         final int var = bc.getMaxLocals();
         if (getListSize(breakList) != nbreaks
             || getListSize(continueList) != ncontinues)
             throw new CompileError(
-                "sorry, cannot break/continue in synchronized block");
+                "sorry, cannot break/continue in synchronized block", st.getLineNumber());
     }
 
     private static int getListSize(List<Integer>  list) {
         else
             msg = "incompatible type for " + expr.getName();
 
-        throw new CompileError(msg);
+        throw new CompileError(msg, expr.getLineNumber());
     }
 
     /* op is either =, %=, &=, *=, /=, +=, -=, ^=, |=, <<=, >>=, or >>>=.
                 int token = assignOps[op - MOD_E];
                 int k = lookupBinOp(token);
                 if (k < 0)
-                    fatal();
+                    fatal(right.getLineNumber());
 
                 atArithBinExpr(expr, token, k, type);
             }
         if (!jvmJavaLangString.equals(cname))
             badAssign(expr);
 
-        convToString(type, dim);    // the value might be null.
+        convToString(type, dim, expr.getLineNumber());    // the value might be null.
         right.accept(this);
-        convToString(exprType, arrayDim);
+        convToString(exprType, arrayDim, expr.getLineNumber());
         bytecode.addInvokevirtual(javaLangString, "concat",
                                 "(Ljava/lang/String;)Ljava/lang/String;");
         exprType = CLASS;
             bytecode.write16bit(pc, bytecode.currentPc() - pc + 1);
             expr.elseExpr().accept(this);
             if (dim1 != arrayDim)
-                throw new CompileError("type mismatch in ?:");
+                throw new CompileError("type mismatch in ?:", expr.getLineNumber());
 
             bytecode.write16bit(pc2, bytecode.currentPc() - pc2 + 1);
         }
             String cname1 = className;
             right.accept(this);
             if (dim1 != arrayDim)
-                throw new CompileError("incompatible array types");
+                throw new CompileError("incompatible array types", expr.getLineNumber());
 
             if (token == '+' && dim1 == 0
                 && (type1 == CLASS || exprType == CLASS))
             = (type2 == CLASS && jvmJavaLangString.equals(className));
 
         if (type2Is2)
-            convToString(type2, dim2);
+            convToString(type2, dim2, expr.getLineNumber());
 
         if (is2word(type1, dim1)) {
             bytecode.addOpcode(DUP_X2);
             bytecode.addOpcode(SWAP);
 
         // even if type1 is String, the left operand might be null.
-        convToString(type1, dim1);
+        convToString(type1, dim1, expr.getLineNumber());
         bytecode.addOpcode(SWAP);
 
         if (!type2Is2 && !type2IsString)
-            convToString(type2, dim2);
+            convToString(type2, dim2, expr.getLineNumber());
 
         bytecode.addInvokevirtual(javaLangString, "concat",
                                 "(Ljava/lang/String;)Ljava/lang/String;");
         className = jvmJavaLangString;
     }
 
-    private void convToString(int type, int dim) throws CompileError {
+    private void convToString(int type, int dim, int lineNumber) throws CompileError {
         final String method = "valueOf";
 
         if (isRefType(type) || dim > 0)
             bytecode.addInvokestatic(javaLangString, method,
                                      "(C)Ljava/lang/String;");
         else if (type == VOID)
-            throw new CompileError("void type expression");
+            throw new CompileError("void type expression", lineNumber);
         else /* INT, BYTE, SHORT */
             bytecode.addInvokestatic(javaLangString, method,
                                      "(I)Ljava/lang/String;");
         else {                          // others
             expr.accept(this);
             if (exprType != BOOLEAN || arrayDim != 0)
-                throw new CompileError("boolean expr is required");
+                throw new CompileError("boolean expr is required", expr.getLineNumber());
 
             bytecode.addOpcode(branchIf ? IFNE : IFEQ);
         }
         expr.oprand2().accept(this);
         if (dim1 != arrayDim)
             if (type1 != NULL && exprType != NULL)
-                throw new CompileError("incompatible array types");
+                throw new CompileError("incompatible array types", expr.getLineNumber());
             else if (exprType == NULL)
                 arrayDim = dim1;
 
                 else if (p == P_LONG)
                     bytecode.addOpcode(LCMP); // 1: >, 0: =, -1: <
                 else
-                    fatal();
+                    fatal(expr.getLineNumber());
 
                 int[] op = ifOp2;
                 for (int i = 0; i < op.length; i += 3)
     }
 
     protected static void badTypes(Expr expr) throws CompileError {
-        throw new CompileError("invalid types for " + expr.getName());
+        throw new CompileError("invalid types for " + expr.getName(), expr.getLineNumber());
     }
 
     private static final int P_DOUBLE = 0;
                 bytecode.addOpcode(SWAP);
             }
             else
-                fatal();
+                fatal(expr.getLineNumber());
         }
         else if (op != NOP)
             bytecode.addOpcode(op);
         int srcDim = arrayDim;
         if (invalidDim(srcType, arrayDim, className, type, dim, name, true)
             || srcType == VOID || type == VOID)
-            throw new CompileError(msg);
+            throw new CompileError(msg, expr.getLineNumber());
 
         if (type == CLASS) {
             if (!isRefType(srcType) && srcDim == 0)
-                throw new CompileError(msg);
+                throw new CompileError(msg, expr.getLineNumber());
 
             return toJvmArrayName(name, dim);
         }
             bytecode.addIconst(0);
         }
         else if (token == CALL)         // method call
-            fatal();
+            fatal(expr.getLineNumber());
         else {
             expr.oprand1().accept(this);
             int type = typePrecedence(exprType);
                 // do nothing. ignore.
             }
             else
-                fatal();
+                fatal(expr.getLineNumber());
         }
     }
 
     protected static void badType(Expr expr) throws CompileError {
-        throw new CompileError("invalid type for " + expr.getName());
+        throw new CompileError("invalid type for " + expr.getName(), expr.getLineNumber());
     }
 
     @Override
     public void atClassObject(Expr expr) throws CompileError {
         ASTree op1 = expr.oprand1();
         if (!(op1 instanceof Symbol))
-            throw new CompileError("fatal error: badly parsed .class expr");
+            throw new CompileError("fatal error: badly parsed .class expr", expr.getLineNumber());
 
         String cname = ((Symbol)op1).get();
         if (cname.startsWith("[")) {
         int type = exprType;
         int dim = arrayDim;
         if (dim == 0)
-            throw new CompileError("bad array access");
+            throw new CompileError("bad array access", array.getLineNumber());
 
         String cname = className;
 
         index.accept(this);
         if (typePrecedence(exprType) != P_INT || arrayDim > 0)
-            throw new CompileError("bad array index");
+            throw new CompileError("bad array index", array.getLineNumber());
 
         exprType = type;
         arrayDim = dim - 1;
         case SUPER :
             if (inStaticMethod)
                 throw new CompileError("not-available: "
-                                       + (token == THIS ? "this" : "super"));
+                                       + (token == THIS ? "this" : "super"), k.getLineNumber());
 
             bytecode.addAload(0);
             exprType = CLASS;
                 className = getSuperName();
             break;
         default :
-            fatal();
+            fatal(k.getLineNumber());
         }
     }
 

src/main/javassist/compiler/CompileError.java

     private Lex lex;
     private String reason;
 
+    private int lineNumber = -1;
+
     public CompileError(String s, Lex l) {
-        reason = s;
+        this(s, l.getLineNumber());
         lex = l;
     }
 
+    public CompileError(String s, int lineNumber) {
+        this.lineNumber = lineNumber;
+        reason = String.format("line %d: %s", lineNumber, s);
+    }
+
     public CompileError(String s) {
         reason = s;
         lex = null;
 
     public Lex getLex() { return lex; }
 
+    public int getLineNumber() {
+        return lineNumber;
+    }
+
     @Override
     public String getMessage() {
         return reason;

src/main/javassist/compiler/Javac.java

 import javassist.compiler.ast.Symbol;
 
 public class Javac {
-    JvstCodeGen gen;
+    JvstCodeGenWitlLineNumber gen;
     SymbolTable stable;
     private Bytecode bytecode;
 
      *                          belongs to.
      */
     public Javac(Bytecode b, CtClass thisClass) {
-        gen = new JvstCodeGen(b, thisClass, thisClass.getClassPool());
+        gen = new JvstCodeGenWitlLineNumber(b, thisClass, thisClass.getClassPool());
         stable = new SymbolTable();
         bytecode = b;
     }
                                                    gen.getThisClass());
                 cons.setModifiers(mod);
                 md.accept(gen);
-                cons.getMethodInfo().setCodeAttribute(
-                                        bytecode.toCodeAttribute());
+                CodeAttribute cattr = bytecode.toCodeAttribute();
+                cattr.setAttribute(gen.toLineNumberAttribute());
+                cons.getMethodInfo().setCodeAttribute(cattr);
                 cons.setExceptionTypes(tlist);
                 return cons;
             }
             method.setModifiers(mod);
             gen.setThisMethod(method);
             md.accept(gen);
-            if (md.getBody() != null)
-                method.getMethodInfo().setCodeAttribute(
-                                    bytecode.toCodeAttribute());
-            else
+            if (md.getBody() != null) {
+                CodeAttribute cattr = bytecode.toCodeAttribute();
+                cattr.setAttribute(gen.toLineNumberAttribute());
+                method.getMethodInfo().setCodeAttribute(cattr);
+            } else
                 method.setModifiers(mod | Modifier.ABSTRACT);
 
             method.setExceptionTypes(tlist);
                 public void doit(JvstCodeGen gen, Bytecode b, ASTList args)
                     throws CompileError
                 {
-                    ASTree expr = new Member(m);
+                    ASTree expr = new Member(m, texpr.getLineNumber());
                     if (texpr != null)
-                        expr = Expr.make('.', texpr, expr);
+                        expr = Expr.make('.', texpr, expr, texpr.getLineNumber());
 
-                    expr = CallExpr.makeCall(expr, args);
+                    expr = CallExpr.makeCall(expr, args, texpr.getLineNumber());
                     gen.compileExpr(expr);
                     gen.addNullIfVoid();
                 }
                 public void setReturnType(JvstTypeChecker check, ASTList args)
                     throws CompileError
                 {
-                    ASTree expr = new Member(m);
+                    ASTree expr = new Member(m, texpr.getLineNumber());
                     if (texpr != null)
-                        expr = Expr.make('.', texpr, expr);
+                        expr = Expr.make('.', texpr, expr, texpr.getLineNumber());
 
-                    expr = CallExpr.makeCall(expr, args);
+                    expr = CallExpr.makeCall(expr, args, texpr.getLineNumber());
                     expr.accept(check);
                     check.addNullIfVoid();
                 }
                     throws CompileError
                 {
                     Expr expr = Expr.make(TokenId.MEMBER,
-                                          new Symbol(c), new Member(m));
-                    expr = CallExpr.makeCall(expr, args);
+                                          new Symbol(c, args.getLineNumber()), new Member(m, args.getLineNumber()), args.getLineNumber());
+                    expr = CallExpr.makeCall(expr, args, args.getLineNumber());
                     gen.compileExpr(expr);
                     gen.addNullIfVoid();
                 }
                     throws CompileError
                 {
                     Expr expr = Expr.make(TokenId.MEMBER,
-                                          new Symbol(c), new Member(m));
-                    expr = CallExpr.makeCall(expr, args);
+                                          new Symbol(c, args.getLineNumber()), new Member(m, args.getLineNumber()), args.getLineNumber());
+                    expr = CallExpr.makeCall(expr, args, args.getLineNumber());
                     expr.accept(check);
                     check.addNullIfVoid();
                 }

src/main/javassist/compiler/JvstCodeGen.java

         }
         else if (name.equals(dollarTypeName)) {
             if (dollarType == null)
-                throw new CompileError(dollarTypeName + " is not available");
+                throw new CompileError(dollarTypeName + " is not available", mem.getLineNumber());
 
             bytecode.addLdc(Descriptor.of(dollarType));
             callGetType("getType");
         }
         else if (name.equals(clazzName)) {
             if (param0Type == null)
-                throw new CompileError(clazzName + " is not available");
+                throw new CompileError(clazzName + " is not available", mem.getLineNumber());
 
             bytecode.addLdc(param0Type);
             callGetType("getClazz");
         if (left instanceof Member
             && ((Member)left).get().equals(paramArrayName)) {
             if (op != '=')
-                throw new CompileError("bad operator for " + paramArrayName);
+                throw new CompileError("bad operator for " + paramArrayName, expr.getLineNumber());
 
             right.accept(this);
             if (arrayDim != 1 || exprType != CLASS)
-                throw new CompileError("invalid type for " + paramArrayName);
+                throw new CompileError("invalid type for " + paramArrayName, expr.getLineNumber());
 
             atAssignParamList(paramTypeList, bytecode);
             if (!doDup)
             className = null;
         }
         else
-            throw new CompileError("invalid cast");
+            throw new CompileError("invalid cast", expr.getLineNumber());
     }
 
     protected void atCastToWrapper(CastExpr expr) throws CompileError {
                 return;
             }
             else if (name.equals(cflowName)) {
-                atCflow((ASTList)expr.oprand2());
+                atCflow((ASTList)expr.oprand2(), expr.getLineNumber());
                 return;
             }
         }
 
     /* To support $cflow().
      */
-    protected void atCflow(ASTList cname) throws CompileError {
+    protected void atCflow(ASTList cname, int lineNumber) throws CompileError {
         StringBuilder sbuf = new StringBuilder();
         if (cname == null || cname.tail() != null)
-            throw new CompileError("bad " + cflowName);
+            throw new CompileError("bad " + cflowName, lineNumber);
 
         makeCflowName(sbuf, cname.head());
         String name = sbuf.toString();
         Object[] names = resolver.getClassPool().lookupCflow(name);
         if (names == null)
-            throw new CompileError("no such " + cflowName + ": " + name);
+            throw new CompileError("no such " + cflowName + ": " + name, lineNumber);
 
         bytecode.addGetstatic((String)names[0], (String)names[1],
                               "Ljavassist/runtime/Cflow;");
             }
         }
 
-        throw new CompileError("bad " + cflowName);
+        throw new CompileError("bad " + cflowName, name.getLineNumber());
     }
 
     /* To support $$.  ($$) is equivalent to ($1, ..., $n).
             String varName = prefix + "0";
             Declarator decl
                 = new Declarator(CLASS, MemberResolver.javaToJvmName(target),
-                                 0, varNo++, new Symbol(varName));
+                                 0, varNo++, new Symbol(varName, 0), 0);
             tbl.append(varName, decl);
         }
 
 
         Declarator decl
             = new Declarator(exprType, className, arrayDim,
-                             varNo, new Symbol(varName));
+                             varNo, new Symbol(varName, 0), 0);
         tbl.append(varName, decl);
         return is2word(exprType, arrayDim) ? 2 : 1;
     }
         }
 
         Declarator decl
-            = new Declarator(type, cname, dim, varNo, new Symbol(varName));
+            = new Declarator(type, cname, dim, varNo, new Symbol(varName, 0), 0);
         tbl.append(varName, decl);
     }
 

src/main/javassist/compiler/JvstCodeGenWitlLineNumber.java

+package javassist.compiler;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.bytecode.Bytecode;
+import javassist.bytecode.LineNumberAttribute;
+import javassist.bytecode.LineNumberAttributeBuilder;
+import javassist.compiler.ast.*;
+
+public class JvstCodeGenWitlLineNumber extends JvstCodeGen {
+    private final LineNumberAttributeBuilder lineNumberAttributeBuilder = new LineNumberAttributeBuilder();
+    public JvstCodeGenWitlLineNumber(Bytecode b, CtClass cc, ClassPool cp) {
+        super(b, cc, cp);
+    }
+
+    public LineNumberAttribute toLineNumberAttribute() {
+        return lineNumberAttributeBuilder.build(bytecode.getConstPool());
+    }
+
+    @Override
+    public void atASTList(ASTList n) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), n);
+        super.atASTList(n);
+    }
+
+    @Override
+    public void atPair(Pair n) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), n);
+        super.atPair(n);
+    }
+
+    @Override
+    public void atSymbol(Symbol n) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), n);
+        super.atSymbol(n);
+    }
+
+    @Override
+    public void atFieldDecl(FieldDecl field) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), field);
+        super.atFieldDecl(field);
+    }
+
+    @Override
+    public void atMethodDecl(MethodDecl method) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), method);
+        super.atMethodDecl(method);
+    }
+
+    @Override
+    public void atMethodBody(Stmnt s, boolean isCons, boolean isVoid) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), s);
+        super.atMethodBody(s, isCons, isVoid);
+    }
+
+    @Override
+    public void atStmnt(Stmnt st) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), st);
+        super.atStmnt(st);
+    }
+
+    @Override
+    public void atDeclarator(Declarator d) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), d);
+        super.atDeclarator(d);
+    }
+
+    @Override
+    public void atAssignExpr(AssignExpr expr) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atAssignExpr(expr);
+    }
+
+    @Override
+    protected void atAssignExpr(AssignExpr expr, boolean doDup) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atAssignExpr(expr, doDup);
+    }
+
+    @Override
+    protected void atAssignCore(Expr expr, int op, ASTree right, int type, int dim, String cname) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atAssignCore(expr, op, right, type, dim, cname);
+    }
+
+    @Override
+    public void atCondExpr(CondExpr expr) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atCondExpr(expr);
+    }
+
+    @Override
+    public void atBinExpr(BinExpr expr) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atBinExpr(expr);
+    }
+
+    @Override
+    public void atInstanceOfExpr(InstanceOfExpr expr) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atInstanceOfExpr(expr);
+    }
+
+    @Override
+    public void atExpr(Expr expr) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atExpr(expr);
+    }
+
+    @Override
+    public void atClassObject(Expr expr) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atClassObject(expr);
+    }
+
+    @Override
+    public void atArrayRead(ASTree array, ASTree index) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), array);
+        super.atArrayRead(array, index);
+    }
+
+    @Override
+    protected void arrayAccess(ASTree array, ASTree index) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), array);
+        super.arrayAccess(array, index);
+    }
+
+    @Override
+    public void atArrayPlusPlus(int token, boolean isPost, Expr expr, boolean doDup) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atArrayPlusPlus(token, isPost, expr, doDup);
+    }
+
+    @Override
+    protected void atPlusPlusCore(int dup_code, boolean doDup, int token, boolean isPost, Expr expr) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atPlusPlusCore(dup_code, doDup, token, isPost, expr);
+    }
+
+    @Override
+    public void atVariable(Variable v) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), v);
+        super.atVariable(v);
+    }
+
+    @Override
+    public void atKeyword(Keyword k) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), k);
+        super.atKeyword(k);
+    }
+
+    @Override
+    public void atStringL(javassist.compiler.ast.StringL s) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), s);
+        super.atStringL(s);
+    }
+
+    @Override
+    public void atIntConst(IntConst i) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), i);
+        super.atIntConst(i);
+    }
+
+    @Override
+    public void atDoubleConst(DoubleConst d) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), d);
+        super.atDoubleConst(d);
+    }
+
+    @Override
+    public void atMember(Member mem) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), mem);
+        super.atMember(mem);
+    }
+
+    @Override
+    protected void atFieldAssign(Expr expr, int op, ASTree left, ASTree right, boolean doDup) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atFieldAssign(expr, op, left, right, doDup);
+    }
+
+    @Override
+    public void atCastExpr(CastExpr expr) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atCastExpr(expr);
+    }
+
+    @Override
+    protected void atCastToRtype(CastExpr expr) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atCastToRtype(expr);
+    }
+
+    @Override
+    protected void atCastToWrapper(CastExpr expr) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atCastToWrapper(expr);
+    }
+
+    @Override
+    public void atCallExpr(CallExpr expr) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atCallExpr(expr);
+    }
+
+    @Override
+    protected void atCflow(ASTList cname, int lineNumber) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), cname);
+        super.atCflow(cname, lineNumber);
+    }
+
+    @Override
+    protected void atTryStmnt(Stmnt st) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), st);
+        super.atTryStmnt(st);
+    }
+
+    @Override
+    public void atNewExpr(NewExpr expr) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atNewExpr(expr);
+    }
+
+    @Override
+    public void atNewArrayExpr(NewExpr expr) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atNewArrayExpr(expr);
+    }
+
+    @Override
+    protected void atArrayVariableAssign(ArrayInit init, int varType, int varArray, String varClass) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), init);
+        super.atArrayVariableAssign(init, varType, varArray, varClass);
+    }
+
+    @Override
+    public void atArrayInit(ArrayInit init) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), init);
+        super.atArrayInit(init);
+    }
+
+    @Override
+    protected void atMultiNewArray(int type, ASTList classname, ASTList size) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), classname);
+        super.atMultiNewArray(type, classname, size);
+    }
+
+    @Override
+    public void atMethodCallCore(CtClass targetClass, String mname, ASTList args, boolean isStatic, boolean isSpecial, int aload0pos, MemberResolver.Method found) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), args);
+        super.atMethodCallCore(targetClass, mname, args, isStatic, isSpecial, aload0pos, found);
+    }
+
+    @Override
+    protected void atFieldRead(ASTree expr) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atFieldRead(expr);
+    }
+
+    @Override
+    protected void atFieldPlusPlus(int token, boolean isPost, ASTree oprand, Expr expr, boolean doDup) throws CompileError {
+        lineNumberAttributeBuilder.put(bytecode.currentPc(), expr);
+        super.atFieldPlusPlus(token, isPost, oprand, expr, doDup);
+    }
+}

src/main/javassist/compiler/JvstTypeChecker.java

 
             int n = params.length;
             for (int i = 0; i < n; ++i)
-                compileUnwrapValue(params[i]);
+                compileUnwrapValue(params[i], expr.getLineNumber());
         }
         else
             super.atFieldAssign(expr, op, left, right);
         CtClass returnType = codeGen.returnType;
         expr.getOprand().accept(this);
         if (exprType == VOID || CodeGen.isRefType(exprType) || arrayDim > 0)
-            compileUnwrapValue(returnType);
+            compileUnwrapValue(returnType, expr.getLineNumber());
         else if (returnType instanceof CtPrimitiveType) {
             CtPrimitiveType pt = (CtPrimitiveType)returnType;
             int destType = MemberResolver.descToType(pt.getDescriptor());
         addNullIfVoid();
     }
 
-    protected void compileUnwrapValue(CtClass type) throws CompileError
+    protected void compileUnwrapValue(CtClass type, int lineNumber) throws CompileError
     {
         if (type == CtClass.voidType)
             addNullIfVoid();

src/main/javassist/compiler/Lex.java

                     ungetc(c);
                     c = '/';
                 }
-            }
+            } else if (c == '\n')
+                ++lineNumber;
         } while(isBlank(c));
         return c;
     }
         lastChar = -1;
         return c;
     }
+
+    public int getLineNumber() {
+        return lineNumber + 1;
+    }
 }

src/main/javassist/compiler/MemberCodeGen.java

         body.accept(this);
         int end = bc.currentPc();
         if (start == end)
-            throw new CompileError("empty try block");
+            throw new CompileError("empty try block", st.getLineNumber());
 
         boolean tryNotReturn = !hasReturned;
         if (tryNotReturn) {
             if (init != null)
                 throw new CompileError(
                         "sorry, multi-dimensional array initializer " +
-                        "for new is not supported");
+                        "for new is not supported", expr.getLineNumber());
 
             atMultiNewArray(type, classname, size);
             return;
         }
 
         ASTree sizeExpr = size.head();
-        atNewArrayExpr2(type, sizeExpr, Declarator.astToClassName(classname, '/'), init);
+        atNewArrayExpr2(type, sizeExpr, Declarator.astToClassName(classname, '/'), init, expr.getLineNumber());
     }
 
     private void atNewArrayExpr2(int type, ASTree sizeExpr,
-                        String jvmClassname, ArrayInit init) throws CompileError {
+                        String jvmClassname, ArrayInit init, int lineNumber) throws CompileError {
         if (init == null)
             if (sizeExpr == null)
-                throw new CompileError("no array size");
+                throw new CompileError("no array size", lineNumber);
             else
                 sizeExpr.accept(this);
         else
                 bytecode.addIconst(s);
             }
             else
-                throw new CompileError("unnecessary array size specified for new");
+                throw new CompileError("unnecessary array size specified for new", lineNumber);
 
         String elementClass;
         if (type == CLASS) {
                 atype = T_LONG;
                 break;
             default :
-                badNewExpr();
+                badNewExpr(lineNumber);
                 break;
             }
 
         className = elementClass;
     }
 
-    private static void badNewExpr() throws CompileError {
-        throw new CompileError("bad new expression");
+    private static void badNewExpr(int lineNumber) throws CompileError {
+        throw new CompileError("bad new expression", lineNumber);
     }
 
     @Override
     protected void atArrayVariableAssign(ArrayInit init, int varType,
                                          int varArray, String varClass) throws CompileError {
-        atNewArrayExpr2(varType, null, varClass, init);
+        atNewArrayExpr2(varType, null, varClass, init, init.getLineNumber());
     }
 
     @Override
     public void atArrayInit(ArrayInit init) throws CompileError {
-        throw new CompileError("array initializer is not supported");
+        throw new CompileError("array initializer is not supported", init.getLineNumber());
     }
 
     protected void atMultiNewArray(int type, ASTList classname, ASTList size)
             ++count;
             s.accept(this);
             if (exprType != INT)
-                throw new CompileError("bad type for array size");
+                throw new CompileError("bad type for array size", classname.getLineNumber());
         }
 
         String desc;
             mname = MethodInfo.nameInit;        // <init>
             targetClass = thisClass;
             if (inStaticMethod)
-                throw new CompileError("a constructor cannot be static");
+                throw new CompileError("a constructor cannot be static", expr.getLineNumber());
             bytecode.addAload(0);   // this
 
             if (((Keyword)method).get() == SUPER)
                 badMethod();
         }
         else
-            fatal();
+            fatal(expr.getLineNumber());
 
         atMethodCallCore(targetClass, mname, args, isStatic, isSpecial,
                          aload0pos, cached);
                 msg = "Method " + mname + " not found in "
                     + targetClass.getName();
 
-            throw new CompileError(msg);
+            throw new CompileError(msg, args.getLineNumber());
         }
 
         atMethodCallCore2(targetClass, mname, isStatic, isSpecial,
         if (op == '=') {
             FieldInfo finfo = f.getFieldInfo2();
             setFieldType(finfo);
-            AccessorMaker maker = isAccessibleField(f, finfo);            
+            AccessorMaker maker = isAccessibleField(f, finfo, expr.getLineNumber());
             if (maker == null)
                 fi = addFieldrefInfo(f, finfo);
             else
                 fi = 0;
         }
         else
-            fi = atFieldRead(f, is_static);
+            fi = atFieldRead(f, is_static, expr.getLineNumber());
 
         int fType = exprType;
         int fDim = arrayDim;
         }
 
         boolean is_static = resultStatic;
-        ASTree cexpr = TypeChecker.getConstantFieldValue(f);
+        ASTree cexpr = TypeChecker.getConstantFieldValue(f, expr.getLineNumber());
         if (cexpr == null)
-            atFieldRead(f, is_static);
+            atFieldRead(f, is_static,expr.getLineNumber() );
         else {
             cexpr.accept(this);
             setFieldType(f.getFieldInfo2());
 
     private void atArrayLength(ASTree expr) throws CompileError {
         if (arrayDim == 0)
-            throw new CompileError(".length applied to a non array");
+            throw new CompileError(".length applied to a non array", expr.getLineNumber());
 
         bytecode.addOpcode(ARRAYLENGTH);
         exprType = INT;
      * It returns a fieldref_info index or zero if the field is a private
      * one declared in an enclosing class. 
      */
-    private int atFieldRead(CtField f, boolean isStatic) throws CompileError {
+    private int atFieldRead(CtField f, boolean isStatic, int lineNumber) throws CompileError {
         FieldInfo finfo = f.getFieldInfo2();
         boolean is2byte = setFieldType(finfo);
-        AccessorMaker maker = isAccessibleField(f, finfo);
+        AccessorMaker maker = isAccessibleField(f, finfo, lineNumber);
         if (maker != null) {
             MethodInfo minfo = maker.getFieldGetter(finfo, isStatic);
             bytecode.addInvokestatic(f.getDeclaringClass(), minfo.getName(),
      * an exception or it returns AccessorMaker if the field is a private
      * one declared in an enclosing class.
      */
-    private AccessorMaker isAccessibleField(CtField f, FieldInfo finfo)
+    private AccessorMaker isAccessibleField(CtField f, FieldInfo finfo, int lineNumber)
         throws CompileError
     {
         if (AccessFlag.isPrivate(finfo.getAccessFlags())
                     return maker;
             }
             throw new CompileError("Field " + f.getName() + " in "
-                                   + declClass.getName() + " is private.");
+                                   + declClass.getName() + " is private.", lineNumber);
         }
 
         return null;    // accessible field
         if (!is_static)
             bytecode.addOpcode(DUP);
 
-        int fi = atFieldRead(f, is_static);
+        int fi = atFieldRead(f, is_static, oprand.getLineNumber());
         int t = exprType;
         boolean is2w = is2word(t, arrayDim);
 
             if (!is_static)
                 if (inStaticMethod)
                     throw new CompileError(
-                                "not available in a static method: " + name);
+                                "not available in a static method: " + name, expr.getLineNumber());
                 else
                     bytecode.addAload(0);       // this
 
                              && ((Symbol)e.oprand2()).get().equals("length"))
                         return null;    // expr is an array length.
                     else
-                        badLvalue();
+                        badLvalue(expr.getLineNumber());
 
                     boolean is_static = Modifier.isStatic(f.getModifiers());
                     if (is_static)
                 }
             }
             else
-                badLvalue();
+                badLvalue(expr.getLineNumber());
         }
         else
-            badLvalue();
+            badLvalue(expr.getLineNumber());
 
         resultStatic = false;
         return null;    // never reach
     }
 
-    private static void badLvalue() throws CompileError {
-        throw new CompileError("bad l-value");
+    private static void badLvalue(int lineNumber) throws CompileError {
+        throw new CompileError("bad l-value", lineNumber);
     }
 
     public CtClass[] makeParamList(MethodDecl md) throws CompileError {

src/main/javassist/compiler/NoFieldException.java

     /* NAME must be JVM-internal representation.
      */
     public NoFieldException(String name, ASTree e) {
-        super("no such field: " + name);
+        super("no such field: " + name, e.getLineNumber());
         fieldName = name;
         expr = e;
     }

src/main/javassist/compiler/Parser.java

         Declarator d;
         boolean isConstructor = false;
         if (lex.lookAhead() == Identifier && lex.lookAhead(1) == '(') {
-            d = new Declarator(VOID, 0);
+            d = new Declarator(VOID, 0, lex.getLineNumber());
             isConstructor = true;
         }
         else
         else
             name = lex.getString();
 
-        d.setVariable(new Symbol(name));
+        d.setVariable(new Symbol(name, lex.getLineNumber()));
         if (isConstructor || lex.lookAhead() == '(')
             return parseMethod1(tbl, isConstructor, mods, d);
         return parseField(tbl, mods, d);
 
         int c = lex.get();
         if (c == ';')
-            return new FieldDecl(mods, new ASTList(d, new ASTList(expr)));
+            return new FieldDecl(mods, new ASTList(d, new ASTList(expr, lex.getLineNumber()), lex.getLineNumber()), lex.getLineNumber());
         else if (c == ',')
             throw new CompileError(
                 "only one field can be declared in one declaration", lex);
         ASTList parms = null;
         if (lex.lookAhead() != ')')
             while (true) {
-                parms = ASTList.append(parms, parseFormalParam(tbl));
+                parms = ASTList.append(parms, parseFormalParam(tbl), lex.getLineNumber());
                 int t = lex.lookAhead();
                 if (t == ',')
                     lex.get();
         if (lex.lookAhead() == THROWS) {
             lex.get();
             while (true) {
-                throwsList = ASTList.append(throwsList, parseClassType(tbl));
+                throwsList = ASTList.append(throwsList, parseClassType(tbl), lex.getLineNumber());
                 if (lex.lookAhead() == ',')
                     lex.get();
                 else
         }
 
         return new MethodDecl(mods, new ASTList(d,
-                                ASTList.make(parms, throwsList, null)));
+                                ASTList.make(parms, throwsList, null, lex.getLineNumber()), lex.getLineNumber()), lex.getLineNumber());
     }
 
     /* Parses a method body.
         else {
             body = parseBlock(tbl);
             if (body == null)
-                body = new Stmnt(BLOCK);
+                body = new Stmnt(BLOCK, lex.getLineNumber());
         }
 
         md.sublist(4).setHead(body);
             if (t == ABSTRACT || t == FINAL || t == PUBLIC || t == PROTECTED
                 || t == PRIVATE || t == SYNCHRONIZED || t == STATIC
                 || t == VOLATILE || t == TRANSIENT || t == STRICT)
-                list = new ASTList(new Keyword(lex.get()), list);
+                list = new ASTList(new Keyword(lex.get(), lex.getLineNumber()), list, lex.getLineNumber());
             else
                 break;
         }
         if (isBuiltinType(t) || t == VOID) {
             lex.get();  // primitive type
             int dim = parseArrayDimension();
-            return new Declarator(t, dim);
+            return new Declarator(t, dim, lex.getLineNumber());
         }
         ASTList name = parseClassType(tbl);
         int dim = parseArrayDimension();
-        return new Declarator(name, dim);
+        return new Declarator(name, dim, lex.getLineNumber());
     }
 
     private static boolean isBuiltinType(int t) {
             throw new SyntaxError(lex);
 
         String name = lex.getString();
-        d.setVariable(new Symbol(name));
+        d.setVariable(new Symbol(name, lex.getLineNumber()));
         d.addArrayDim(parseArrayDimension());
         tbl.append(name, d);
         return d;
             return parseBlock(tbl);
         else if (t == ';') {
             lex.get();
-            return new Stmnt(BLOCK);    // empty statement
+            return new Stmnt(BLOCK, lex.getLineNumber());    // empty statement
         }
         else if (t == Identifier && lex.lookAhead(1) == ':') {
             lex.get();  // Identifier
             String label = lex.getString();
             lex.get();  // ':'
-            return Stmnt.make(LABEL, new Symbol(label), parseStatement(tbl));
+            return Stmnt.make(LABEL, new Symbol(label, lex.getLineNumber()), parseStatement(tbl), lex.getLineNumber());
         }
         else if (t == IF)
             return parseIf(tbl);
         while (lex.lookAhead() != '}') {
             Stmnt s = parseStatement(tbl2);
             if (s != null)
-                body = (Stmnt)ASTList.concat(body, new Stmnt(BLOCK, s));
+                body = (Stmnt)ASTList.concat(body, new Stmnt(BLOCK, s, lex.getLineNumber()));
         }
 
         lex.get();      // '}'
         if (body == null)
-            return new Stmnt(BLOCK);    // empty block
+            return new Stmnt(BLOCK, lex.getLineNumber());    // empty block
         return body;
     }
 
         else
             elsep = null;
 
-        return new Stmnt(t, expr, new ASTList(thenp, new ASTList(elsep)));
+        return new Stmnt(t, expr, new ASTList(thenp, new ASTList(elsep, lex.getLineNumber()), lex.getLineNumber()), lex.getLineNumber());
     }
 
     /* while.statement : WHILE "(" expression ")" statement
         int t = lex.get();      // WHILE
         ASTree expr = parseParExpression(tbl);
         Stmnt body = parseStatement(tbl);
-        return new Stmnt(t, expr, body);
+        return new Stmnt(t, expr, body, lex.getLineNumber());
     }
 
     /* do.statement : DO statement WHILE "(" expression ")" ";"
         if (lex.get() != ')' || lex.get() != ';')
             throw new SyntaxError(lex);
 
-        return new Stmnt(t, expr, body);
+        return new Stmnt(t, expr, body, lex.getLineNumber());
     }
 
     /* for.statement : FOR "(" decl.or.expr expression ";" expression ")"
 
         Stmnt body = parseStatement(tbl2);
         return new Stmnt(t, expr1, new ASTList(expr2,
-                                               new ASTList(expr3, body)));
+                                               new ASTList(expr3, body, lex.getLineNumber()), lex.getLineNumber()), lex.getLineNumber());
     }
 
     /* switch.statement : SWITCH "(" expression ")" "{" switch.block "}"
         int t = lex.get();	// SWITCH
         ASTree expr = parseParExpression(tbl);
         Stmnt body = parseSwitchBlock(tbl);
-        return new Stmnt(t, expr, body);
+        return new Stmnt(t, expr, body, lex.getLineNumber());
     }
 
     private Stmnt parseSwitchBlock(SymbolTable tbl) throws CompileError {
             throw new CompileError("no case or default in a switch block",
                                    lex);
 
-        Stmnt body = new Stmnt(BLOCK, s);
+        Stmnt body = new Stmnt(BLOCK, s, lex.getLineNumber());
         while (lex.lookAhead() != '}') {
             Stmnt s2 = parseStmntOrCase(tbl2);
             if (s2 != null) {
                 int op2 = s2.getOperator();
                 if (op2 == CASE || op2 == DEFAULT) {
-                    body = (Stmnt)ASTList.concat(body, new Stmnt(BLOCK, s2));
+                    body = (Stmnt)ASTList.concat(body, new Stmnt(BLOCK, s2, lex.getLineNumber()));
                     s = s2;
                 }
                 else
-                    s = (Stmnt)ASTList.concat(s, new Stmnt(BLOCK, s2));
+                    s = (Stmnt)ASTList.concat(s, new Stmnt(BLOCK, s2, lex.getLineNumber()));
             }
         }
 
         lex.get();
         Stmnt s;
         if (t == CASE)
-            s = new Stmnt(t, parseExpression(tbl));
+            s = new Stmnt(t, parseExpression(tbl), lex.getLineNumber());
         else
-            s = new Stmnt(DEFAULT);
+            s = new Stmnt(DEFAULT, lex.getLineNumber());
 
         if (lex.get() != ':')
             throw new CompileError(": is missing", lex);
             throw new SyntaxError(lex);
 
         Stmnt body = parseBlock(tbl);
-        return new Stmnt(t, expr, body);
+        return new Stmnt(t, expr, body, lex.getLineNumber());
     }
 
     /* try.statement
                 throw new SyntaxError(lex);
 
             Stmnt b = parseBlock(tbl2);
-            catchList = ASTList.append(catchList, new Pair(d, b));
+            catchList = ASTList.append(catchList, new Pair(d, b), lex.getLineNumber());
         }
 
         Stmnt finallyBlock = null;
             finallyBlock = parseBlock(tbl);
         }
 
-        return Stmnt.make(TRY, block, catchList, finallyBlock);
+        return Stmnt.make(TRY, block, catchList, finallyBlock, lex.getLineNumber());
     }
 
     /* return.statement : RETURN [ expression ] ";"
      */
     private Stmnt parseReturn(SymbolTable tbl) throws CompileError {
         int t = lex.get();      // RETURN
-        Stmnt s = new Stmnt(t);
+        Stmnt s = new Stmnt(t, lex.getLineNumber());
         if (lex.lookAhead() != ';')
             s.setLeft(parseExpression(tbl));
 
         if (lex.get() != ';')
             throw new CompileError("; is missing", lex);
 
-        return new Stmnt(t, expr);
+        return new Stmnt(t, expr, lex.getLineNumber());
     }
 
     /* break.statement : BREAK [ Identifier ] ";"
         throws CompileError
     {
         int t = lex.get();      // CONTINUE
-        Stmnt s = new Stmnt(t);
+        Stmnt s = new Stmnt(t, lex.getLineNumber());
         int t2 = lex.get();
         if (t2 == Identifier) {
-            s.setLeft(new Symbol(lex.getString()));
+            s.setLeft(new Symbol(lex.getString(), lex.getLineNumber()));
             t2 = lex.get();
         }
 
         if (isBuiltinType(t)) {
             t = lex.get();
             int dim = parseArrayDimension();
-            return parseDeclarators(tbl, new Declarator(t, dim));
+            return parseDeclarators(tbl, new Declarator(t, dim, lex.getLineNumber()));
         }
         else if (t == Identifier) {
             int i = nextIsClassType(0);
                 if (lex.lookAhead(i) == Identifier) {
                     ASTList name = parseClassType(tbl);
                     int dim = parseArrayDimension();
-                    return parseDeclarators(tbl, new Declarator(name, dim));
+                    return parseDeclarators(tbl, new Declarator(name, dim, lex.getLineNumber()));
                 }
         }
 
         if (exprList)
             expr = parseExprList(tbl);
         else
-            expr = new Stmnt(EXPR, parseExpression(tbl));
+            expr = new Stmnt(EXPR, parseExpression(tbl), lex.getLineNumber());
 
         if (lex.get() != ';')
             throw new CompileError("; is missing", lex);
     private Stmnt parseExprList(SymbolTable tbl) throws CompileError {
         Stmnt expr = null;
         for (;;) {
-            Stmnt e = new Stmnt(EXPR, parseExpression(tbl));
-            expr = (Stmnt)ASTList.concat(expr, new Stmnt(BLOCK, e));
+            Stmnt e = new Stmnt(EXPR, parseExpression(tbl), lex.getLineNumber());
+            expr = (Stmnt)ASTList.concat(expr, new Stmnt(BLOCK, e, lex.getLineNumber()));
             if (lex.lookAhead() == ',')
                 lex.get();
             else
         Stmnt decl = null;
         for (;;) {
             decl = (Stmnt)ASTList.concat(decl,
-                                new Stmnt(DECL, parseDeclarator(tbl, d)));
+                                new Stmnt(DECL, parseDeclarator(tbl, d), lex.getLineNumber()));
             int t = lex.get();
             if (t == ';')
                 return decl;
             throw new SyntaxError(lex);
 
         String name = lex.getString();
-        Symbol symbol = new Symbol(name);
+        Symbol symbol = new Symbol(name, lex.getLineNumber());
         int dim = parseArrayDimension();
         ASTree init = null;
         if (lex.lookAhead() == '=') {
             init = parseInitializer(tbl);
         }
 
-        Declarator decl = d.make(symbol, dim, init);
+        Declarator decl = d.make(symbol, dim, init, lex.getLineNumber());
         tbl.append(name, decl);
         return decl;
     }
         lex.get();      // '{'
         if(lex.lookAhead() == '}'){
             lex.get();
-            return new ArrayInit(null);
+            return new ArrayInit(null, lex.getLineNumber());
         }
         ASTree expr = parseExpression(tbl);
-        ArrayInit init = new ArrayInit(expr);
+        ArrayInit init = new ArrayInit(expr, lex.getLineNumber());
         while (lex.lookAhead() == ',') {
             lex.get();
             expr = parseExpression(tbl);
-            ASTList.append(init, expr);
+            ASTList.append(init, expr, lex.getLineNumber());
         }
 
         if (lex.get() != '}')
 
         int t = lex.get();
         ASTree right = parseExpression(tbl);
-        return AssignExpr.makeAssign(t, left, right);
+        return AssignExpr.makeAssign(t, left, right, lex.getLineNumber());
     }
 
     private static boolean isAssignOp(int t) {
                 throw new CompileError(": is missing", lex);
 
             ASTree elseExpr = parseExpression(tbl);
-            return new CondExpr(cond, thenExpr, elseExpr);
+            return new CondExpr(cond, thenExpr, elseExpr, lex.getLineNumber());
         }
         return cond;
     }
         if (isBuiltinType(t)) {
             lex.get();  // primitive type
             int dim = parseArrayDimension();
-            return new InstanceOfExpr(t, dim, expr);
+            return new InstanceOfExpr(t, dim, expr, lex.getLineNumber());
         }
         ASTList name = parseClassType(tbl);
         int dim = parseArrayDimension();
-        return new InstanceOfExpr(name, dim, expr);
+        return new InstanceOfExpr(name, dim, expr, lex.getLineNumber());
     }
 
     private ASTree binaryExpr2(SymbolTable tbl, ASTree expr, int prec)
             if (p2 != 0 && prec > p2)
                 expr2 = binaryExpr2(tbl, expr2, p2);
             else
-                return BinExpr.makeBin(t, expr, expr2);
+                return BinExpr.makeBin(t, expr, expr2, lex.getLineNumber());
         }
     }
 
                 case IntConstant :
                 case CharConstant :
                     lex.get();
-                    return new IntConst(-lex.getLong(), t2);
+                    return new IntConst(-lex.getLong(), t2, lex.getLineNumber());
                 case DoubleConstant :
                 case FloatConstant :
                     lex.get();
-                    return new DoubleConst(-lex.getDouble(), t2);
+                    return new DoubleConst(-lex.getDouble(), t2, lex.getLineNumber());
                 default :
                     break;
                 }
             }
 
-            return Expr.make(t, parseUnaryExpr(tbl));
+            return Expr.make(t, parseUnaryExpr(tbl), lex.getLineNumber());
         case '(' :
             return parseCast(tbl);
         default :
             if (lex.get() != ')')
                 throw new CompileError(") is missing", lex);
 
-            return new CastExpr(t, dim, parseUnaryExpr(tbl));
+            return new CastExpr(t, dim, parseUnaryExpr(tbl), lex.getLineNumber());
         }
         else if (t == Identifier && nextIsClassCast()) {
             lex.get();  // '('
             if (lex.get() != ')')
                 throw new CompileError(") is missing", lex);
 
-            return new CastExpr(name, dim, parseUnaryExpr(tbl));
+            return new CastExpr(name, dim, parseUnaryExpr(tbl), lex.getLineNumber());
         }
         else
             return parsePostfix(tbl);
             if (lex.get() != Identifier)
                 throw new SyntaxError(lex);
 
-            list = ASTList.append(list, new Symbol(lex.getString()));
+            list = ASTList.append(list, new Symbol(lex.getString(), lex.getLineNumber()), lex.getLineNumber());
             if (lex.lookAhead() == '.')
                 lex.get();
             else
         case IntConstant :
         case CharConstant :
             lex.get();
-            return new IntConst(lex.getLong(), token);
+            return new IntConst(lex.getLong(), token, lex.getLineNumber());
         case DoubleConstant :
         case FloatConstant :
             lex.get();
-            return new DoubleConst(lex.getDouble(), token);
+            return new DoubleConst(lex.getDouble(), token, lex.getLineNumber());
         default :
             break;
         }
                     if (index == null)
                         throw new SyntaxError(lex);
 
-                    expr = Expr.make(ARRAY, expr, index);
+                    expr = Expr.make(ARRAY, expr, index, lex.getLineNumber());
                 }
                 break;
             case PLUSPLUS :
             case MINUSMINUS :
                 t = lex.get();
-                expr = Expr.make(t, null, expr);
+                expr = Expr.make(t, null, expr, lex.getLineNumber());
                 break;
             case '.' :
                 lex.get();
                 if (t == CLASS)
                     expr = parseDotClass(expr, 0);
                 else if (t == SUPER)
-                    expr = Expr.make('.', new Symbol(toClassName(expr)), new Keyword(t));
+                    expr = Expr.make('.', new Symbol(toClassName(expr), lex.getLineNumber()), new Keyword(t, lex.getLineNumber()), lex.getLineNumber());
                 else if (t == Identifier) {
                     str = lex.getString();
-                    expr = Expr.make('.', expr, new Member(str));
+                    expr = Expr.make('.', expr, new Member(str, lex.getLineNumber()), lex.getLineNumber());
                 }
                 else
                     throw new CompileError("missing member name", lex);
                     throw new CompileError("missing static member name", lex);
 
                 str = lex.getString();
-                expr = Expr.make(MEMBER, new Symbol(toClassName(expr)),
-                                 new Member(str));
+                expr = Expr.make(MEMBER, new Symbol(toClassName(expr), lex.getLineNumber()),
+                                 new Member(str, lex.getLineNumber()), lex.getLineNumber());
                 break;
             default :
                 return expr;
             cname = sbuf.toString();
         }
 
-        return Expr.make('.', new Symbol(cname), new Member("class"));
+        return Expr.make('.', new Symbol(cname, className.getLineNumber()), new Member("class", className.getLineNumber()), lex.getLineNumber());
     }
 
     /* Parses a .class expression on a built-in type.  For example,
     {
         if (dim > 0) {
             String cname = CodeGen.toJvmTypeName(builtinType, dim);
-            return Expr.make('.', new Symbol(cname), new Member("class"));
+            return Expr.make('.', new Symbol(cname, lex.getLineNumber()), new Member("class", lex.getLineNumber()), lex.getLineNumber());
         }
         String cname;
         switch(builtinType) {
             break;
         default :
             throw new CompileError("invalid builtin type: "
-                                   + builtinType);
+                                   + builtinType, lex);
         }
 
-        return Expr.make(MEMBER, new Symbol(cname), new Member("TYPE"));
+        return Expr.make(MEMBER, new Symbol(cname, lex.getLineNumber()), new Member("TYPE", lex.getLineNumber()), lex.getLineNumber());
     }
 
     /* method.call : method.expr "(" argument.list ")"
                 throw new SyntaxError(lex);
         }
 
-        return CallExpr.makeCall(expr, parseArgumentList(tbl));
+        return CallExpr.makeCall(expr, parseArgumentList(tbl), lex.getLineNumber());
     }
 
     private String toClassName(ASTree name)
         case TRUE :
         case FALSE :
         case NULL :
-            return new Keyword(t);
+            return new Keyword(t, lex.getLineNumber());
         case Identifier :
             name = lex.getString();
             decl = tbl.lookup(name);
             if (decl == null)
-                return new Member(name);        // this or static member
-            return new Variable(name, decl); // local variable
+                return new Member(name, lex.getLineNumber());        // this or static member
+            return new Variable(name, decl, lex.getLineNumber()); // local variable
         case StringL :
-            return new StringL(lex.getString());
+            return new StringL(lex.getString(), lex.getLineNumber());
         case NEW :
             return parseNew(tbl);
         case '(' :
             if (lex.lookAhead() == '{')
                 init = parseArrayInitializer(tbl);
 
-            return new NewExpr(t, size, init);
+            return new NewExpr(t, size, init, lex.getLineNumber());
         }
         else if (t == Identifier) {
             ASTList name = parseClassType(tbl);
             t = lex.lookAhead();
             if (t == '(') {
                 ASTList args = parseArgumentList(tbl);
-                return new NewExpr(name, args);
+                return new NewExpr(name, args, lex.getLineNumber());
             }
             else if (t == '[') {
                 ASTList size = parseArraySize(tbl);
                 if (lex.lookAhead() == '{')
                     init = parseArrayInitializer(tbl);
 
-                return NewExpr.makeObjectArray(name, size, init);
+                return NewExpr.makeObjectArray(name, size, init, lex.getLineNumber());
             }
         }
 
     private ASTList parseArraySize(SymbolTable tbl) throws CompileError {
         ASTList list = null;
         while (lex.lookAhead() == '[')
-            list = ASTList.append(list, parseArrayIndex(tbl));
+            list = ASTList.append(list, parseArrayIndex(tbl), lex.getLineNumber());
 
         return list;
     }
         ASTList list = null;
         if (lex.lookAhead() != ')')
             for (;;) {
-                list = ASTList.append(list, parseExpression(tbl));
+                list = ASTList.append(list, parseExpression(tbl), lex.getLineNumber());
                 if (lex.lookAhead() == ',')
                     lex.get();
                 else

src/main/javassist/compiler/TypeChecker.java

         thisMethod = m;
     }
 
-    protected static void fatal() throws CompileError {
-        throw new CompileError("fatal");
+    protected static void fatal(int lineLum) throws CompileError {
+        throw new CompileError("fatal", lineLum);
     }
 
     /**
 
         if (dim1 == 0 && dim1 == arrayDim)
             if (CodeGen.rightIsStrong(type1, exprType))
-                expr.setThen(new CastExpr(exprType, 0, expr.thenExpr()));
+                expr.setThen(new CastExpr(exprType, 0, expr.thenExpr(), expr.getLineNumber()));
             else if (CodeGen.rightIsStrong(exprType, type1)) {
-                expr.setElse(new CastExpr(type1, 0, expr.elseExpr()));
+                expr.setElse(new CastExpr(type1, 0, expr.elseExpr(), expr.getLineNumber()));
                 exprType = type1;
             }
     }
                      * an expression using StringBuffer.
                      */
                     e = CallExpr.makeCall(Expr.make('.', e,
-                                            new Member("toString")), null);
+                                            new Member("toString", expr.getLineNumber()), expr.getLineNumber()), null, expr.getLineNumber());
                     expr.setOprand1(e);
                     expr.setOprand2(null);    // <---- look at this!
                     className = jvmJavaLangString;
         if ((type1 == CLASS && dim1 == 0 && jvmJavaLangString.equals(cname))
             || (exprType == CLASS && arrayDim == 0
                 && jvmJavaLangString.equals(className))) {
-            ASTList sbufClass = ASTList.make(new Symbol("java"),
-                            new Symbol("lang"), new Symbol("StringBuffer"));
-            ASTree e = new NewExpr(sbufClass, null);
+            int lineNum = expr.getLineNumber();
+            ASTList sbufClass = ASTList.make(new Symbol("java", lineNum),
+                            new Symbol("lang", lineNum), new Symbol("StringBuffer", lineNum), lineNum);
+            ASTree e = new NewExpr(sbufClass, null, lineNum);
             exprType = CLASS;
             arrayDim = 0;
             className = "java/lang/StringBuffer";
         ASTree newExpr = null;
         if (left instanceof StringL && right instanceof StringL && op == '+')
             newExpr = new StringL(((StringL)left).get()
-                                  + ((StringL)right).get());
+                                  + ((StringL)right).get(), left.getLineNumber());
         else if (left instanceof IntConst)
             newExpr = ((IntConst)left).compute(op, right);
         else if (left instanceof DoubleConst)
             Expr e = (Expr)expr;
             int op = e.getOperator();
             if (op == MEMBER) {
-                ASTree cexpr = getConstantFieldValue((Member)e.oprand2());
+                ASTree cexpr = getConstantFieldValue((Member)e.oprand2(), expr.getLineNumber());
                 if (cexpr != null)
                     return cexpr;
             }
                 return e.getLeft();
         }
         else if (expr instanceof Member) {
-            ASTree cexpr = getConstantFieldValue((Member)expr);
+            ASTree cexpr = getConstantFieldValue((Member)expr, expr.getLineNumber());
             if (cexpr != null)
                 return cexpr;
         }
      * If MEM is a static final field, this method returns a constant
      * expression representing the value of that field.
      */
-    private static ASTree getConstantFieldValue(Member mem) {
-        return getConstantFieldValue(mem.getField());
+    private static ASTree getConstantFieldValue(Member mem, int lineNumber) {
+        return getConstantFieldValue(mem.getField(), lineNumber);
     }
 
-    public static ASTree getConstantFieldValue(CtField f) {
+    public static ASTree getConstantFieldValue(CtField f, int lineNumber) {
         if (f == null)
             return null;
 
             return null;
 
         if (value instanceof String)
-            return new StringL((String)value);
+            return new StringL((String)value, lineNumber);
         else if (value instanceof Double || value instanceof Float) {
             int token = (value instanceof Double)
                         ? DoubleConstant : FloatConstant;
-            return new DoubleConst(((Number)value).doubleValue(), token);
+            return new DoubleConst(((Number)value).doubleValue(), token, lineNumber);
         }
         else if (value instanceof Number) {
             int token = (value instanceof Long) ? LongConstant : IntConstant; 
-            return new IntConst(((Number)value).longValue(), token);
+            return new IntConst(((Number)value).longValue(), token, lineNumber);
         }
         else if (value instanceof Boolean)
             return new Keyword(((Boolean)value).booleanValue()
-                               ? TokenId.TRUE : TokenId.FALSE);
+                               ? TokenId.TRUE : TokenId.FALSE, lineNumber);
         else
             return null;
     }
     }
 
     private static Expr makeAppendCall(ASTree target, ASTree arg) {
-        return CallExpr.makeCall(Expr.make('.', target, new Member("append")),
-                                 new ASTList(arg));
+        return CallExpr.makeCall(Expr.make('.', target, new Member("append", target.getLineNumber()), target.getLineNumber()),
+                                 new ASTList(arg, target.getLineNumber()), target.getLineNumber());
     }
 
     private void computeBinExprType(BinExpr expr, int token, int type1)
         throws CompileError
     {
         if (CodeGen.rightIsStrong(type1, type2))
-            expr.setLeft(new CastExpr(type2, 0, expr.oprand1()));
+            expr.setLeft(new CastExpr(type2, 0, expr.oprand1(), expr.getLineNumber()));
         else
             exprType = type1;
     }
         else if (token == '!')
             booleanExpr(expr);
         else if (token == CALL)              // method call
-            fatal();
+            fatal(expr.getLineNumber());
         else {
             oprand.accept(this);
             if (!isConstant(expr, token, oprand))
                         className = nfe.getField(); // JVM-internal
                         e.setOperator(MEMBER);
                         e.setOprand1(new Symbol(MemberResolver.jvmToJavaName(
-                                                                className)));
+                                                                className), e.getLineNumber()));
                     }
 
                     if (arrayDim > 0)
                 badMethod();
         }
         else
-            fatal();
+            fatal(expr.getLineNumber());
 
         MemberResolver.Method minfo
                 = atMethodCallCore(targetClass, mname, args);
             }
         }
 
-        throw new CompileError("bad field access");
+        throw new CompileError("bad field access", expr.getLineNumber());
     }
 
     private CtField fieldAccess2(Expr e, String jvmClassName) throws CompileError {
         Member fname = (Member)e.oprand2();
         CtField f = resolver.lookupFieldByJvmName2(jvmClassName, fname, e);
         e.setOperator(MEMBER);
-        e.setOprand1(new Symbol(MemberResolver.jvmToJavaName(jvmClassName)));
+        e.setOprand1(new Symbol(MemberResolver.jvmToJavaName(jvmClassName), e.getLineNumber()));
         fname.setField(f);
         return f;
     }
                 className = getSuperName();
             break;
         default :
-            fatal();
+            fatal(k.getLineNumber());
         }
     }
 

src/main/javassist/compiler/ast/ASTList.java

     private ASTree left;
     private ASTList right;
 
-    public ASTList(ASTree _head, ASTList _tail) {
+    public ASTList(ASTree _head, ASTList _tail, int lineNumber) {
+        super(lineNumber);
         left = _head;
         right = _tail;
     }
 
-    public ASTList(ASTree _head) {
-        left = _head;
-        right = null;
+    public ASTList(ASTree _head, int lineNumber) {
+        this(_head, null, lineNumber);
     }
 
-    public static ASTList make(ASTree e1, ASTree e2, ASTree e3) {
-        return new ASTList(e1, new ASTList(e2, new ASTList(e3)));
+    public static ASTList make(ASTree e1, ASTree e2, ASTree e3 , int lineNumber) {
+        return new ASTList(e1, new ASTList(e2, new ASTList(e3, lineNumber), lineNumber), lineNumber);
     }
 
     @Override
     /**
      * Appends an object to a list.
      */
-    public static ASTList append(ASTList a, ASTree b) {
-        return concat(a, new ASTList(b));
+    public static ASTList append(ASTList a, ASTree b, int lineNumber) {
+        return concat(a, new ASTList(b, lineNumber));
     }
 
     /**

src/main/javassist/compiler/ast/ASTree.java

     /** default serialVersionUID */
     private static final long serialVersionUID = 1L;
 
+    private final int lineNumber;
+
+    public ASTree(int lineNumber) {
+        this.lineNumber = lineNumber;
+    }
+
     public ASTree getLeft() { return null; }
 
     public ASTree getRight() { return null; }
         String name = getClass().getName();
         return name.substring(name.lastIndexOf('.') + 1);
     }
+
+    public int getLineNumber() {
+        return lineNumber;
+    }
 }

src/main/javassist/compiler/ast/ArrayInit.java

 
     /**
      * Constructs an object.
-     * @param firstElement      maybe null when the initializer is <code>{}</code> (empty).
+     *
+     * @param firstElement maybe null when the initializer is <code>{}</code> (empty).
+     * @param lineNumber
      */
-    public ArrayInit(ASTree firstElement) {
-        super(firstElement);
+    public ArrayInit(ASTree firstElement, int lineNumber) {
+        super(firstElement, lineNumber);
     }
 
     /**

src/main/javassist/compiler/ast/AssignExpr.java

     /** default serialVersionUID */
     private static final long serialVersionUID = 1L;
 
-    private AssignExpr(int op, ASTree _head, ASTList _tail) {
-        super(op, _head, _tail);
+    private AssignExpr(int op, ASTree _head, ASTList _tail, int lineNumber) {
+        super(op, _head, _tail, lineNumber);
     }
 
     public static AssignExpr makeAssign(int op, ASTree oprand1,
-                                        ASTree oprand2) {
-        return new AssignExpr(op, oprand1, new ASTList(oprand2));
+                                        ASTree oprand2, int lineNumber) {
+        return new AssignExpr(op, oprand1, new ASTList(oprand2, lineNumber), lineNumber);
     }
 
     @Override

src/main/javassist/compiler/ast/BinExpr.java

     /** default serialVersionUID */
     private static final long serialVersionUID = 1L;
 
-    private BinExpr(int op, ASTree _head, ASTList _tail) {
-        super(op, _head, _tail);
+    private BinExpr(int op, ASTree _head, ASTList _tail, int lineNumber) {
+        super(op, _head, _tail, lineNumber);
     }
 
-    public static BinExpr makeBin(int op, ASTree oprand1, ASTree oprand2) {
-        return new BinExpr(op, oprand1, new ASTList(oprand2));
+    public static BinExpr makeBin(int op, ASTree oprand1, ASTree oprand2, int lineNumber) {
+        return new BinExpr(op, oprand1, new ASTList(oprand2, lineNumber), lineNumber);
     }
 
     @Override

src/main/javassist/compiler/ast/CallExpr.java

     private static final long serialVersionUID = 1L;
     private MemberResolver.Method method;  // cached result of lookupMethod()
 
-    private CallExpr(ASTree _head, ASTList _tail) {
-        super(TokenId.CALL, _head, _tail);
+    private CallExpr(ASTree _head, ASTList _tail, int lineNumber) {
+        super(TokenId.CALL, _head, _tail, lineNumber);
         method = null;
     }
 
         return method;
     }
 
-    public static CallExpr makeCall(ASTree target, ASTree args) {
-        return new CallExpr(target, new ASTList(args));
+    public static CallExpr makeCall(ASTree target, ASTree args, int lineNumber) {
+        return new CallExpr(target, new ASTList(args, lineNumber), lineNumber);
     }
 
     @Override

src/main/javassist/compiler/ast/CastExpr.java

     protected int castType;
     protected int arrayDim;
 
-    public CastExpr(ASTList className, int dim, ASTree expr) {
-        super(className, new ASTList(expr));
+    public CastExpr(ASTList className, int dim, ASTree expr, int lineNumber) {
+        super(className, new ASTList(expr, lineNumber), lineNumber);
         castType = CLASS;
         arrayDim = dim;
     }
 
-    public CastExpr(int type, int dim, ASTree expr) {
-        super(null, new ASTList(expr));
+    public CastExpr(int type, int dim, ASTree expr, int lineNumber) {
+        super(null, new ASTList(expr, lineNumber), lineNumber);
         castType = type;
         arrayDim = dim;
     }

src/main/javassist/compiler/ast/CondExpr.java

     /** default serialVersionUID */
     private static final long serialVersionUID = 1L;
 
-    public CondExpr(ASTree cond, ASTree thenp, ASTree elsep) {
-        super(cond, new ASTList(thenp, new ASTList(elsep)));
+    public CondExpr(ASTree cond, ASTree thenp, ASTree elsep, int lineNumber) {
+        super(cond, new ASTList(thenp, new ASTList(elsep, lineNumber), lineNumber), lineNumber);
     }
 
     public ASTree condExpr() { return head(); }

src/main/javassist/compiler/ast/Declarator.java

     protected int localVar;
     protected String qualifiedClass;    // JVM-internal representation
 
-    public Declarator(int type, int dim) {
-        super(null);
+    public Declarator(int type, int dim, int lineNumber) {
+        super(null, lineNumber);
         varType = type;
         arrayDim = dim;
         localVar = -1;
         qualifiedClass = null;
     }
 
-    public Declarator(ASTList className, int dim) {
-        super(null);
+    public Declarator(ASTList className, int dim, int lineNumber) {
+        super(null, lineNumber);
         varType = CLASS;
         arrayDim = dim;
         localVar = -1;
     /* For declaring a pre-defined? local variable.
      */
     public Declarator(int type, String jvmClassName, int dim,
-                      int var, Symbol sym) {
-        super(null);
+                      int var, Symbol sym, int lineNumber) {
+        super(null, lineNumber);
         varType = type;
         arrayDim = dim;
         localVar = var;
         qualifiedClass = jvmClassName;
         setLeft(sym);
-        append(this, null);     // initializer
+        append(this, null, lineNumber);     // initializer
     }
 
-    public Declarator make(Symbol sym, int dim, ASTree init) {
-        Declarator d = new Declarator(this.varType, this.arrayDim + dim);
+    public Declarator make(Symbol sym, int dim, ASTree init, int lineNumber) {
+        Declarator d = new Declarator(this.varType, this.arrayDim + dim, lineNumber);
         d.qualifiedClass = this.qualifiedClass;
         d.setLeft(sym);
-        append(d, init);
+        append(d, init, lineNumber);
         return d;
     }
 

src/main/javassist/compiler/ast/DoubleConst.java

     protected double value;
     protected int type;
 
-    public DoubleConst(double v, int tokenId) { value = v; type = tokenId; }
+    public DoubleConst(double v, int tokenId, int lineNumber) {
+        super(lineNumber);
+        value = v;
+        type = tokenId;
+    }
 
     public double get() { return value; }
 
         else
             newType = TokenId.FloatConstant;
 
-        return compute(op, this.value, right.value, newType);
+        return compute(op, this.value, right.value, newType, getLineNumber());
     }
 
     private DoubleConst compute0(int op, IntConst right) {
-        return compute(op, this.value, right.value, this.type);
+        return compute(op, this.value, right.value, this.type, getLineNumber());
     }
 
     private static DoubleConst compute(int op, double value1, double value2,
-                                       int newType)
+                                       int newType, int lineNumber)
     {
         double newValue;
         switch (op) {
             return null;
         }
 
-        return new DoubleConst(newValue, newType);
+        return new DoubleConst(newValue, newType, lineNumber);
     }
 }

src/main/javassist/compiler/ast/Expr.java

     private static final long serialVersionUID = 1L;
     protected int operatorId;
 
-    Expr(int op, ASTree _head, ASTList _tail) {
-        super(_head, _tail);
+    Expr(int op, ASTree _head, ASTList _tail, int lineNumber) {
+        super(_head, _tail, lineNumber);
         operatorId = op;
     }
 
-    Expr(int op, ASTree _head) {
-        super(_head);
+    Expr(int op, ASTree _head, int lineNumber) {
+        super(_head, lineNumber);
         operatorId = op;
     }
 
-    public static Expr make(int op, ASTree oprand1, ASTree oprand2) {
-        return new Expr(op, oprand1, new ASTList(oprand2));
+    public static Expr make(int op, ASTree oprand1, ASTree oprand2, int lineNumber) {
+        return new Expr(op, oprand1, new ASTList(oprand2, lineNumber), lineNumber);
     }
 
-    public static Expr make(int op, ASTree oprand1) {
-        return new Expr(op, oprand1);
+    public static Expr make(int op, ASTree oprand1, int lineNumber) {
+        return new Expr(op, oprand1, lineNumber);
     }
 
     public int getOperator() { return operatorId; }

src/main/javassist/compiler/ast/FieldDecl.java

     /** default serialVersionUID */
     private static final long serialVersionUID = 1L;
 
-    public FieldDecl(ASTree _head, ASTList _tail) {
-        super(_head, _tail);
+    public FieldDecl(ASTree _head, ASTList _tail, int lineNumber) {
+        super(_head, _tail, lineNumber);
     }
 
     public ASTList getModifiers() { return (ASTList)getLeft(); }

src/main/javassist/compiler/ast/InstanceOfExpr.java

     /** default serialVersionUID */
     private static final long serialVersionUID = 1L;
 
-    public InstanceOfExpr(ASTList className, int dim, ASTree expr) {
-        super(className, dim, expr);
+    public InstanceOfExpr(ASTList className, int dim, ASTree expr, int lineNumber) {
+        super(className, dim, expr, lineNumber);
     }
 
-    public InstanceOfExpr(int type, int dim, ASTree expr) {
-        super(type, dim, expr);
+    public InstanceOfExpr(int type, int dim, ASTree expr, int lineNumber) {
+        super(type, dim, expr, lineNumber);
     }
 
     @Override

src/main/javassist/compiler/ast/IntConst.java

     protected long value;
     protected int type;
 
-    public IntConst(long v, int tokenId) { value = v; type = tokenId; }
+    public IntConst(long v, int tokenId, int lineNumber) {
+        super(lineNumber);
+        value = v;
+        type = tokenId;
+    }
 
     public long get() { return value; }
 
             return null;
         }
 
-        return new IntConst(newValue, newType);
+        return new IntConst(newValue, newType, right.getLineNumber());
     }
 
     private DoubleConst compute0(int op, DoubleConst right) {
             return null;
         }
 
-        return new DoubleConst(newValue, right.type);
+        return new DoubleConst(newValue, right.type, right.getLineNumber());
     }
 }

src/main/javassist/compiler/ast/Keyword.java

     private static final long serialVersionUID = 1L;
     protected int tokenId;
 
-    public Keyword(int token) {
+    public Keyword(int token, int lineNumber) {
+        super(lineNumber);
         tokenId = token;
     }
 

src/main/javassist/compiler/ast/Member.java

     // this is used to obtain the value of a static final field.
     private CtField field;
 
-    public Member(String name) {
-        super(name);
+    public Member(String name, int lineNumber) {
+        super(name, lineNumber);
         field = null;
     }
 

src/main/javassist/compiler/ast/MethodDecl.java

     private static final long serialVersionUID = 1L;
     public static final String initName = "<init>";
 
-    public MethodDecl(ASTree _head, ASTList _tail) {
-        super(_head, _tail);
+    public MethodDecl(ASTree _head, ASTList _tail, int lineNumber) {
+        super(_head, _tail, lineNumber);
     }
 
     public boolean isConstructor() {

src/main/javassist/compiler/ast/NewExpr.java

     protected boolean newArray;
     protected int arrayType;
 
-    public NewExpr(ASTList className, ASTList args) {
-        super(className, new ASTList(args));
+    public NewExpr(ASTList className, ASTList args, int lineNumber) {
+        super(className, new ASTList(args, lineNumber), lineNumber);
         newArray = false;
         arrayType = CLASS;
     }
 
-    public NewExpr(int type, ASTList arraySize, ArrayInit init) {
-        super(null, new ASTList(arraySize));
+    public NewExpr(int type, ASTList arraySize, ArrayInit init, int lineNumber) {
+        super(null, new ASTList(arraySize, lineNumber), lineNumber);
         newArray = true;
         arrayType = type;
         if (init != null)
-            append(this, init);
+            append(this, init, lineNumber);
     }
 
     public static NewExpr makeObjectArray(ASTList className,
-                                          ASTList arraySize, ArrayInit init) {
-        NewExpr e = new NewExpr(className, arraySize);
+                                          ASTList arraySize, ArrayInit init, int lineNumber) {
+        NewExpr e = new NewExpr(className, arraySize, lineNumber);
         e.newArray = true;
         if (init != null)
-            append(e, init);
+            append(e, init, lineNumber);
 
         return e;
     }

src/main/javassist/compiler/ast/Pair.java

     protected ASTree left, right;
 
     public Pair(ASTree _left, ASTree _right) {
+        super(_left.getLineNumber());
         left = _left;
         right = _right;
     }

src/main/javassist/compiler/ast/Stmnt.java

     private static final long serialVersionUID = 1L;
     protected int operatorId;
 
-    public Stmnt(int op, ASTree _head, ASTList _tail) {
-        super(_head, _tail);
+    public Stmnt(int op, ASTree _head, ASTList _tail, int lineNumber) {
+        super(_head, _tail, lineNumber);
         operatorId = op;
     }
 
-    public Stmnt(int op, ASTree _head) {
-        super(_head);
+    public Stmnt(int op, ASTree _head, int lineNumber) {
+        super(_head, lineNumber);
         operatorId = op;
     }
 
-    public Stmnt(int op) {
-        this(op, null);
+    public Stmnt(int op, int lineNumber) {
+        this(op, null, lineNumber);
     }
 
-    public static Stmnt make(int op, ASTree oprand1, ASTree oprand2) {
-        return new Stmnt(op, oprand1, new ASTList(oprand2));
+    public static Stmnt make(int op, ASTree oprand1, ASTree oprand2, int lineNumber) {
+        return new Stmnt(op, oprand1, new ASTList(oprand2, lineNumber), lineNumber);
     }
 
-    public static Stmnt make(int op, ASTree op1, ASTree op2, ASTree op3) {
-        return new Stmnt(op, op1, new ASTList(op2, new ASTList(op3)));
+    public static Stmnt make(int op, ASTree op1, ASTree op2, ASTree op3, int lineNumber) {
+        return new Stmnt(op, op1, new ASTList(op2, new ASTList(op3, lineNumber), lineNumber), lineNumber);
     }
 
     @Override

src/main/javassist/compiler/ast/StringL.java

     private static final long serialVersionUID = 1L;
     protected String text;
 
-    public StringL(String t) {
+    public StringL(String t, int lineNumber) {
+        super(lineNumber);
         text = t;
     }
 

src/main/javassist/compiler/ast/Symbol.java

     private static final long serialVersionUID = 1L;
     protected String identifier;
 
-    public Symbol(String sym) {
+    public Symbol(String sym, int lineNumber) {
+        super(lineNumber);
         identifier = sym;
     }
 

src/main/javassist/compiler/ast/Variable.java

     private static final long serialVersionUID = 1L;
     protected Declarator declarator;
 
-    public Variable(String sym, Declarator d) {
-        super(sym);
+    public Variable(String sym, Declarator d, int lineNumber) {
+        super(sym, lineNumber);
         declarator = d;
     }
 

src/test/javassist/bytecode/BytecodeTest.java

         assertEquals(20, pc.line);
     }
 
+    public void testLineNumberCompiler() {
+        CtClass testClass = loader.makeClass("javassist.bytecode.LineNumberCompilerClass");
+        String run = String.join("\n",
+                "public void run() {",
+                "    return",
+                "}");
+        try {
+            testClass.addMethod(CtMethod.make(run, testClass));
+        } catch (CannotCompileException e) {
+            assertEquals("line 3: syntax error near \"  return\n}\"", e.getCause().getMessage());
+            return;
+        }
+        fail("should not happen");
+    }
+
+    public void testLineNumberException() {
+        CtClass testClass = loader.makeClass("javassist.bytecode.LineNumberExceptionClass");
+        String run = String.join("\n",
+                "public void run() {",
+                "    throw new java.lang.RuntimeException();",
+                "}");
+        try {
+            testClass.addInterface(loader.get("java.lang.Runnable"));
+            testClass.addMethod(CtMethod.make(run, testClass));
+            Class cls = testClass.toClass(BytecodeTest.class);
+            var runnable = (Runnable) cls.getConstructor().newInstance();
+            runnable.run();
+        } catch (Exception e) {
+            var lineNum = e.getStackTrace()[0].getLineNumber();
+            assertEquals("Line number should be right", 2, lineNum);
+            return;
+        }
+        fail("should not happen");
+    }
+
     public void testRenameClass() throws Exception {
         CtClass cc = loader.get("test1.RenameClass");
         cc.replaceClassName("test1.RenameClass2", "java.lang.String");