From 312b86f15919efe4593b5121d5e64634ded8f1f9 Mon Sep 17 00:00:00 2001
From: gaojunkang <gaojunkang@xiaohongshu.com>
Date: Mon, 29 Jul 2024 13:42:13 +0800
Subject: [PATCH] refactor: replace typo lookhead with lookahead

---
 examples/calculator.av                        |  18 +-
 .../aviator/AviatorEvaluatorInstance.java     |   8 +-
 .../aviator/code/CodeGenerator.java           |  80 ++--
 .../aviator/code/LambdaGenerator.java         | 164 +++----
 .../aviator/code/NoneCodeGenerator.java       |  84 ++--
 .../aviator/code/OptimizeCodeGenerator.java   | 190 ++++----
 .../aviator/code/asm/ASMCodeGenerator.java    | 224 ++++-----
 .../interpreter/InterpretCodeGenerator.java   | 112 ++---
 .../aviator/lexer/token/OperatorToken.java    |   8 +-
 .../aviator/parser/ExpressionParser.java      | 428 +++++++++---------
 .../aviator/parser/FakeCodeGenerator.java     |  90 ++--
 11 files changed, 703 insertions(+), 703 deletions(-)

diff --git a/examples/calculator.av b/examples/calculator.av
index 2d27a694..6a075d05 100644
--- a/examples/calculator.av
+++ b/examples/calculator.av
@@ -69,7 +69,7 @@ fn expr(parser, tokens) {
   term(parser, tokens);
 
   while true {
-    let t = parser.lookhead;
+    let t = parser.lookahead;
 
     if t.val == '+' {
       parser.move();
@@ -89,7 +89,7 @@ fn term(parser, tokens) {
   unary(parser, tokens);
 
   while true {
-    let t = parser.lookhead;
+    let t = parser.lookahead;
 
     if t.val == '*' {
       parser.move();
@@ -106,7 +106,7 @@ fn term(parser, tokens) {
 }
 
 fn unary(parser, tokens) {
-  let t = parser.lookhead;
+  let t = parser.lookahead;
   if t.val == '-' {
     parser.move();
     unary(parser, tokens);
@@ -117,12 +117,12 @@ fn unary(parser, tokens) {
 }
 
 fn factor(parser, tokens) {
-  let t = parser.lookhead;
+  let t = parser.lookahead;
 
   if t.val == '(' {
     parser.move();
     expr(parser, tokens);
-    t = parser.lookhead;
+    t = parser.lookahead;
     if t.val != ')'{
       error(t);
     }
@@ -137,10 +137,10 @@ fn factor(parser, tokens) {
 
 fn parser(lexer) {
   let parser = seq.map();
-  parser.lookhead = lexer();
+  parser.lookahead = lexer();
 
   parser.move = fn() {
-    parser.lookhead = lexer();
+    parser.lookahead = lexer();
   };
 
   return parser;
@@ -153,8 +153,8 @@ fn parse(s) {
 
   expr(parser, tokens);
 
-  if parser.lookhead.type != EOF {
-    error(parser.lookhead);
+  if parser.lookahead.type != EOF {
+    error(parser.lookahead);
   }
 
   return tokens;
diff --git a/src/main/java/com/googlecode/aviator/AviatorEvaluatorInstance.java b/src/main/java/com/googlecode/aviator/AviatorEvaluatorInstance.java
index 13eab1ef..bbdff43b 100644
--- a/src/main/java/com/googlecode/aviator/AviatorEvaluatorInstance.java
+++ b/src/main/java/com/googlecode/aviator/AviatorEvaluatorInstance.java
@@ -1828,12 +1828,12 @@ public StringSegments compileStringSegments(final String lexeme, final String so
                   new ExpressionParser(this, lexer, newCodeGenerator(sourceFile, false));
 
               Expression exp = parser.parse(false);
-              final Token<?> lookhead = parser.getLookhead();
-              if (lookhead == null || (lookhead.getType() != TokenType.Char
-                  || ((CharToken) lookhead).getCh() != '}')) {
+              final Token<?> lookahead = parser.getLookahead();
+              if (lookahead == null || (lookahead.getType() != TokenType.Char
+                  || ((CharToken) lookahead).getCh() != '}')) {
                 parser.reportSyntaxError("expect '}' to complete string interpolation");
               }
-              int expStrLen = lookhead.getStartIndex() + 1;
+              int expStrLen = lookahead.getStartIndex() + 1;
               while (expStrLen-- > 0) {
                 prev = ch;
                 ch = it.next();
diff --git a/src/main/java/com/googlecode/aviator/code/CodeGenerator.java b/src/main/java/com/googlecode/aviator/code/CodeGenerator.java
index 32f9a341..05d5df50 100644
--- a/src/main/java/com/googlecode/aviator/code/CodeGenerator.java
+++ b/src/main/java/com/googlecode/aviator/code/CodeGenerator.java
@@ -29,118 +29,118 @@
  */
 public interface CodeGenerator {
 
-  public void onAssignment(Token<?> lookhead);
+  public void onAssignment(Token<?> lookahead);
 
   public void setParser(Parser parser);
 
-  public void onShiftRight(Token<?> lookhead);
+  public void onShiftRight(Token<?> lookahead);
 
 
-  public void onShiftLeft(Token<?> lookhead);
+  public void onShiftLeft(Token<?> lookahead);
 
 
-  public void onUnsignedShiftRight(Token<?> lookhead);
+  public void onUnsignedShiftRight(Token<?> lookahead);
 
 
-  public void onBitOr(Token<?> lookhead);
+  public void onBitOr(Token<?> lookahead);
 
 
-  public void onBitAnd(Token<?> lookhead);
+  public void onBitAnd(Token<?> lookahead);
 
 
-  public void onBitXor(Token<?> lookhead);
+  public void onBitXor(Token<?> lookahead);
 
 
-  public void onBitNot(Token<?> lookhead);
+  public void onBitNot(Token<?> lookahead);
 
 
-  public void onAdd(Token<?> lookhead);
+  public void onAdd(Token<?> lookahead);
 
 
-  public void onSub(Token<?> lookhead);
+  public void onSub(Token<?> lookahead);
 
 
-  public void onMult(Token<?> lookhead);
+  public void onMult(Token<?> lookahead);
 
   public void onExponent(Token<?> loohead);
 
 
-  public void onDiv(Token<?> lookhead);
+  public void onDiv(Token<?> lookahead);
 
 
-  public void onAndLeft(Token<?> lookhead);
+  public void onAndLeft(Token<?> lookahead);
 
 
-  public void onAndRight(Token<?> lookhead);
+  public void onAndRight(Token<?> alookahead);
 
 
-  public void onTernaryBoolean(Token<?> lookhead);
+  public void onTernaryBoolean(Token<?> lookahead);
 
 
-  public void onTernaryLeft(Token<?> lookhead);
+  public void onTernaryLeft(Token<?> lookahead);
 
 
-  public void onTernaryRight(Token<?> lookhead);
+  public void onTernaryRight(Token<?> lookahead);
 
-  public void onTernaryEnd(Token<?> lookhead);
+  public void onTernaryEnd(Token<?> lookahead);
 
 
-  public void onJoinLeft(Token<?> lookhead);
+  public void onJoinLeft(Token<?> lookahead);
 
 
-  public void onJoinRight(Token<?> lookhead);
+  public void onJoinRight(Token<?> lookahead);
 
 
-  public void onEq(Token<?> lookhead);
+  public void onEq(Token<?> lookahead);
 
 
-  public void onMatch(Token<?> lookhead);
+  public void onMatch(Token<?> lookahead);
 
 
-  public void onNeq(Token<?> lookhead);
+  public void onNeq(Token<?> lookahead);
 
 
-  public void onLt(Token<?> lookhead);
+  public void onLt(Token<?> lookahead);
 
 
-  public void onLe(Token<?> lookhead);
+  public void onLe(Token<?> lookahead);
 
 
-  public void onGt(Token<?> lookhead);
+  public void onGt(Token<?> lookahead);
 
 
-  public void onGe(Token<?> lookhead);
+  public void onGe(Token<?> lookahead);
 
 
-  public void onMod(Token<?> lookhead);
+  public void onMod(Token<?> lookahead);
 
 
-  public void onNot(Token<?> lookhead);
+  public void onNot(Token<?> lookahead);
 
 
-  public void onNeg(Token<?> lookhead);
+  public void onNeg(Token<?> lookahead);
 
   public Expression getResult(boolean unboxObject);
 
-  public void onConstant(Token<?> lookhead);
+  public void onConstant(Token<?> lookahead);
 
-  public void onMethodName(Token<?> lookhead);
+  public void onMethodName(Token<?> lookahead);
 
-  public void onMethodParameter(Token<?> lookhead);
+  public void onMethodParameter(Token<?> lookahead);
 
-  public void onMethodInvoke(Token<?> lookhead);
+  public void onMethodInvoke(Token<?> lookahead);
 
-  public void onLambdaDefineStart(Token<?> lookhead);
+  public void onLambdaDefineStart(Token<?> lookahead);
 
-  public void onLambdaArgument(Token<?> lookhead, FunctionParam param);
+  public void onLambdaArgument(Token<?> lookahead, FunctionParam param);
 
-  public void onLambdaBodyStart(Token<?> lookhead);
+  public void onLambdaBodyStart(Token<?> lookahead);
 
-  public void onLambdaBodyEnd(Token<?> lookhead);
+  public void onLambdaBodyEnd(Token<?> lookahead);
 
-  public void onArray(Token<?> lookhead);
+  public void onArray(Token<?> lookahead);
 
   public void onArrayIndexStart(Token<?> token);
 
-  public void onArrayIndexEnd(Token<?> lookhead);
+  public void onArrayIndexEnd(Token<?> lookahead);
 }
diff --git a/src/main/java/com/googlecode/aviator/code/LambdaGenerator.java b/src/main/java/com/googlecode/aviator/code/LambdaGenerator.java
index ff1f527f..8aac66b1 100644
--- a/src/main/java/com/googlecode/aviator/code/LambdaGenerator.java
+++ b/src/main/java/com/googlecode/aviator/code/LambdaGenerator.java
@@ -210,212 +210,212 @@ public void addParam(final FunctionParam name) {
 
 
   @Override
-  public void onShiftRight(final Token<?> lookhead) {
-    this.codeGenerator.onShiftRight(lookhead);
+  public void onShiftRight(final Token<?> lookahead) {
+    this.codeGenerator.onShiftRight(lookahead);
   }
 
 
 
   @Override
-  public void onShiftLeft(final Token<?> lookhead) {
-    this.codeGenerator.onShiftLeft(lookhead);
+  public void onShiftLeft(final Token<?> lookahead) {
+    this.codeGenerator.onShiftLeft(lookahead);
   }
 
 
 
   @Override
-  public void onUnsignedShiftRight(final Token<?> lookhead) {
-    this.codeGenerator.onUnsignedShiftRight(lookhead);
+  public void onUnsignedShiftRight(final Token<?> lookahead) {
+    this.codeGenerator.onUnsignedShiftRight(lookahead);
   }
 
 
 
   @Override
-  public void onAssignment(final Token<?> lookhead) {
-    this.codeGenerator.onAssignment(lookhead);
+  public void onAssignment(final Token<?> lookahead) {
+    this.codeGenerator.onAssignment(lookahead);
   }
 
 
   @Override
-  public void onBitOr(final Token<?> lookhead) {
-    this.codeGenerator.onBitOr(lookhead);
+  public void onBitOr(final Token<?> lookahead) {
+    this.codeGenerator.onBitOr(lookahead);
   }
 
 
   @Override
-  public void onBitAnd(final Token<?> lookhead) {
-    this.codeGenerator.onBitAnd(lookhead);
+  public void onBitAnd(final Token<?> lookahead) {
+    this.codeGenerator.onBitAnd(lookahead);
   }
 
 
 
   @Override
-  public void onBitXor(final Token<?> lookhead) {
-    this.codeGenerator.onBitXor(lookhead);
+  public void onBitXor(final Token<?> lookahead) {
+    this.codeGenerator.onBitXor(lookahead);
   }
 
 
 
   @Override
-  public void onBitNot(final Token<?> lookhead) {
-    this.codeGenerator.onBitNot(lookhead);
+  public void onBitNot(final Token<?> lookahead) {
+    this.codeGenerator.onBitNot(lookahead);
   }
 
 
 
   @Override
-  public void onAdd(final Token<?> lookhead) {
-    this.codeGenerator.onAdd(lookhead);
+  public void onAdd(final Token<?> lookahead) {
+    this.codeGenerator.onAdd(lookahead);
   }
 
   @Override
-  public void onSub(final Token<?> lookhead) {
-    this.codeGenerator.onSub(lookhead);
+  public void onSub(final Token<?> lookahead) {
+    this.codeGenerator.onSub(lookahead);
   }
 
 
 
   @Override
-  public void onMult(final Token<?> lookhead) {
-    this.codeGenerator.onMult(lookhead);
+  public void onMult(final Token<?> lookahead) {
+    this.codeGenerator.onMult(lookahead);
   }
 
 
 
   @Override
-  public void onExponent(final Token<?> lookhead) {
-    this.codeGenerator.onExponent(lookhead);
+  public void onExponent(final Token<?> lookahead) {
+    this.codeGenerator.onExponent(lookahead);
   }
 
 
   @Override
-  public void onDiv(final Token<?> lookhead) {
-    this.codeGenerator.onDiv(lookhead);
+  public void onDiv(final Token<?> lookahead) {
+    this.codeGenerator.onDiv(lookahead);
   }
 
 
 
   @Override
-  public void onAndLeft(final Token<?> lookhead) {
-    this.codeGenerator.onAndLeft(lookhead);
+  public void onAndLeft(final Token<?> lookahead) {
+    this.codeGenerator.onAndLeft(lookahead);
   }
 
 
 
   @Override
-  public void onAndRight(final Token<?> lookhead) {
-    this.codeGenerator.onAndRight(lookhead);
+  public void onAndRight(final Token<?> alookahead) {
+    this.codeGenerator.onAndRight(alookahead);
   }
 
 
 
   @Override
-  public void onTernaryBoolean(final Token<?> lookhead) {
-    this.codeGenerator.onTernaryBoolean(lookhead);
+  public void onTernaryBoolean(final Token<?> lookahead) {
+    this.codeGenerator.onTernaryBoolean(lookahead);
   }
 
 
 
   @Override
-  public void onTernaryLeft(final Token<?> lookhead) {
-    this.codeGenerator.onTernaryLeft(lookhead);
+  public void onTernaryLeft(final Token<?> lookahead) {
+    this.codeGenerator.onTernaryLeft(lookahead);
   }
 
 
 
   @Override
-  public void onTernaryRight(final Token<?> lookhead) {
-    this.codeGenerator.onTernaryRight(lookhead);
+  public void onTernaryRight(final Token<?> lookahead) {
+    this.codeGenerator.onTernaryRight(lookahead);
   }
 
 
 
   @Override
-  public void onTernaryEnd(final Token<?> lookhead) {
-    this.codeGenerator.onTernaryEnd(lookhead);
+  public void onTernaryEnd(final Token<?> lookahead) {
+    this.codeGenerator.onTernaryEnd(lookahead);
   }
 
 
   @Override
-  public void onJoinLeft(final Token<?> lookhead) {
-    this.codeGenerator.onJoinLeft(lookhead);
+  public void onJoinLeft(final Token<?> lookahead) {
+    this.codeGenerator.onJoinLeft(lookahead);
   }
 
 
 
   @Override
-  public void onJoinRight(final Token<?> lookhead) {
-    this.codeGenerator.onJoinRight(lookhead);
+  public void onJoinRight(final Token<?> lookahead) {
+    this.codeGenerator.onJoinRight(lookahead);
   }
 
 
 
   @Override
-  public void onEq(final Token<?> lookhead) {
-    this.codeGenerator.onEq(lookhead);
+  public void onEq(final Token<?> lookahead) {
+    this.codeGenerator.onEq(lookahead);
   }
 
 
 
   @Override
-  public void onMatch(final Token<?> lookhead) {
-    this.codeGenerator.onMatch(lookhead);
+  public void onMatch(final Token<?> lookahead) {
+    this.codeGenerator.onMatch(lookahead);
   }
 
 
 
   @Override
-  public void onNeq(final Token<?> lookhead) {
-    this.codeGenerator.onNeq(lookhead);
+  public void onNeq(final Token<?> lookahead) {
+    this.codeGenerator.onNeq(lookahead);
   }
 
 
 
   @Override
-  public void onLt(final Token<?> lookhead) {
-    this.codeGenerator.onLt(lookhead);
+  public void onLt(final Token<?> lookahead) {
+    this.codeGenerator.onLt(lookahead);
   }
 
 
 
   @Override
-  public void onLe(final Token<?> lookhead) {
-    this.codeGenerator.onLe(lookhead);
+  public void onLe(final Token<?> lookahead) {
+    this.codeGenerator.onLe(lookahead);
   }
 
 
 
   @Override
-  public void onGt(final Token<?> lookhead) {
-    this.codeGenerator.onGt(lookhead);
+  public void onGt(final Token<?> lookahead) {
+    this.codeGenerator.onGt(lookahead);
   }
 
 
 
   @Override
-  public void onGe(final Token<?> lookhead) {
-    this.codeGenerator.onGe(lookhead);
+  public void onGe(final Token<?> lookahead) {
+    this.codeGenerator.onGe(lookahead);
   }
 
 
 
   @Override
-  public void onMod(final Token<?> lookhead) {
-    this.codeGenerator.onMod(lookhead);
+  public void onMod(final Token<?> lookahead) {
+    this.codeGenerator.onMod(lookahead);
   }
 
 
 
   @Override
-  public void onNot(final Token<?> lookhead) {
-    this.codeGenerator.onNot(lookhead);
+  public void onNot(final Token<?> lookahead) {
+    this.codeGenerator.onNot(lookahead);
   }
 
 
 
   @Override
-  public void onNeg(final Token<?> lookhead) {
-    this.codeGenerator.onNeg(lookhead);
+  public void onNeg(final Token<?> lookahead) {
+    this.codeGenerator.onNeg(lookahead);
   }
 
 
@@ -426,55 +426,55 @@ public Expression getResult(final boolean unboxObject) {
 
 
   @Override
-  public void onConstant(final Token<?> lookhead) {
-    this.codeGenerator.onConstant(lookhead);
+  public void onConstant(final Token<?> lookahead) {
+    this.codeGenerator.onConstant(lookahead);
   }
 
   @Override
-  public void onMethodName(final Token<?> lookhead) {
-    this.codeGenerator.onMethodName(lookhead);
+  public void onMethodName(final Token<?> lookahead) {
+    this.codeGenerator.onMethodName(lookahead);
   }
 
 
 
   @Override
-  public void onMethodParameter(final Token<?> lookhead) {
-    this.codeGenerator.onMethodParameter(lookhead);
+  public void onMethodParameter(final Token<?> lookahead) {
+    this.codeGenerator.onMethodParameter(lookahead);
   }
 
   @Override
-  public void onMethodInvoke(final Token<?> lookhead) {
-    this.codeGenerator.onMethodInvoke(lookhead);
+  public void onMethodInvoke(final Token<?> lookahead) {
+    this.codeGenerator.onMethodInvoke(lookahead);
   }
 
 
 
   @Override
-  public void onLambdaDefineStart(final Token<?> lookhead) {
-    this.codeGenerator.onLambdaDefineStart(lookhead);
+  public void onLambdaDefineStart(final Token<?> lookahead) {
+    this.codeGenerator.onLambdaDefineStart(lookahead);
   }
 
 
 
   @Override
-  public void onLambdaArgument(final Token<?> lookhead, final FunctionParam param) {
-    this.codeGenerator.onLambdaArgument(lookhead, param);
+  public void onLambdaArgument(final Token<?> lookahead, final FunctionParam param) {
+    this.codeGenerator.onLambdaArgument(lookahead, param);
   }
 
   @Override
-  public void onLambdaBodyStart(final Token<?> lookhead) {
-    this.codeGenerator.onLambdaBodyStart(lookhead);
+  public void onLambdaBodyStart(final Token<?> lookahead) {
+    this.codeGenerator.onLambdaBodyStart(lookahead);
   }
 
   @Override
-  public void onLambdaBodyEnd(final Token<?> lookhead) {
+  public void onLambdaBodyEnd(final Token<?> lookahead) {
     // should call parent generator
-    this.parentCodeGenerator.onLambdaBodyEnd(lookhead);
+    this.parentCodeGenerator.onLambdaBodyEnd(lookahead);
   }
 
   @Override
-  public void onArray(final Token<?> lookhead) {
-    this.codeGenerator.onArray(lookhead);
+  public void onArray(final Token<?> lookahead) {
+    this.codeGenerator.onArray(lookahead);
   }
 
   @Override
@@ -483,8 +483,8 @@ public void onArrayIndexStart(final Token<?> token) {
   }
 
   @Override
-  public void onArrayIndexEnd(final Token<?> lookhead) {
-    this.codeGenerator.onArrayIndexEnd(lookhead);
+  public void onArrayIndexEnd(final Token<?> lookahead) {
+    this.codeGenerator.onArrayIndexEnd(lookahead);
   }
 
 }
diff --git a/src/main/java/com/googlecode/aviator/code/NoneCodeGenerator.java b/src/main/java/com/googlecode/aviator/code/NoneCodeGenerator.java
index 59055327..a8daa669 100644
--- a/src/main/java/com/googlecode/aviator/code/NoneCodeGenerator.java
+++ b/src/main/java/com/googlecode/aviator/code/NoneCodeGenerator.java
@@ -20,7 +20,7 @@ public class NoneCodeGenerator implements CodeGenerator {
   private Parser parser;
 
   @Override
-  public void onAssignment(final Token<?> lookhead) {
+  public void onAssignment(final Token<?> lookahead) {
 
 
   }
@@ -31,61 +31,61 @@ public void setParser(final Parser parser) {
   }
 
   @Override
-  public void onShiftRight(final Token<?> lookhead) {
+  public void onShiftRight(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onShiftLeft(final Token<?> lookhead) {
+  public void onShiftLeft(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onUnsignedShiftRight(final Token<?> lookhead) {
+  public void onUnsignedShiftRight(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onBitOr(final Token<?> lookhead) {
+  public void onBitOr(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onBitAnd(final Token<?> lookhead) {
+  public void onBitAnd(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onBitXor(final Token<?> lookhead) {
+  public void onBitXor(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onBitNot(final Token<?> lookhead) {
+  public void onBitNot(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onAdd(final Token<?> lookhead) {
+  public void onAdd(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onSub(final Token<?> lookhead) {
+  public void onSub(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onMult(final Token<?> lookhead) {
+  public void onMult(final Token<?> lookahead) {
 
 
   }
@@ -93,120 +93,120 @@ public void onMult(final Token<?> lookhead) {
 
 
   @Override
-  public void onExponent(final Token<?> lookhead) {
+  public void onExponent(final Token<?> lookahead) {
 
   }
 
   @Override
-  public void onDiv(final Token<?> lookhead) {
+  public void onDiv(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onAndLeft(final Token<?> lookhead) {
+  public void onAndLeft(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onAndRight(final Token<?> lookhead) {
+  public void onAndRight(final Token<?> alookahead) {
 
 
   }
 
   @Override
-  public void onTernaryBoolean(final Token<?> lookhead) {
+  public void onTernaryBoolean(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onTernaryLeft(final Token<?> lookhead) {
+  public void onTernaryLeft(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onTernaryRight(final Token<?> lookhead) {
+  public void onTernaryRight(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onTernaryEnd(final Token<?> lookhead) {
+  public void onTernaryEnd(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onJoinLeft(final Token<?> lookhead) {
+  public void onJoinLeft(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onJoinRight(final Token<?> lookhead) {
+  public void onJoinRight(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onEq(final Token<?> lookhead) {
+  public void onEq(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onMatch(final Token<?> lookhead) {
+  public void onMatch(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onNeq(final Token<?> lookhead) {
+  public void onNeq(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onLt(final Token<?> lookhead) {
+  public void onLt(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onLe(final Token<?> lookhead) {
+  public void onLe(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onGt(final Token<?> lookhead) {
+  public void onGt(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onGe(final Token<?> lookhead) {
+  public void onGe(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onMod(final Token<?> lookhead) {
+  public void onMod(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onNot(final Token<?> lookhead) {
+  public void onNot(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onNeg(final Token<?> lookhead) {
+  public void onNeg(final Token<?> lookahead) {
 
 
   }
@@ -218,54 +218,54 @@ public Expression getResult(final boolean unboxObject) {
   }
 
   @Override
-  public void onConstant(final Token<?> lookhead) {
+  public void onConstant(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onMethodName(final Token<?> lookhead) {
+  public void onMethodName(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onMethodParameter(final Token<?> lookhead) {
+  public void onMethodParameter(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onMethodInvoke(final Token<?> lookhead) {
+  public void onMethodInvoke(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onLambdaDefineStart(final Token<?> lookhead) {
-    Boolean newLexicalScope = lookhead.getMeta(Constants.SCOPE_META, false);
+  public void onLambdaDefineStart(final Token<?> lookahead) {
+    Boolean newLexicalScope = lookahead.getMeta(Constants.SCOPE_META, false);
     this.infos.push(this.parser.enterScope(newLexicalScope));
   }
 
   @Override
-  public void onLambdaArgument(final Token<?> lookhead, final FunctionParam param) {
+  public void onLambdaArgument(final Token<?> lookahead, final FunctionParam param) {
 
 
   }
 
   @Override
-  public void onLambdaBodyStart(final Token<?> lookhead) {
+  public void onLambdaBodyStart(final Token<?> lookahead) {
 
 
   }
 
   @Override
-  public void onLambdaBodyEnd(final Token<?> lookhead) {
+  public void onLambdaBodyEnd(final Token<?> lookahead) {
     this.parser.restoreScope(this.infos.pop());
   }
 
   @Override
-  public void onArray(final Token<?> lookhead) {
+  public void onArray(final Token<?> lookahead) {
 
 
   }
@@ -277,7 +277,7 @@ public void onArrayIndexStart(final Token<?> token) {
   }
 
   @Override
-  public void onArrayIndexEnd(final Token<?> lookhead) {
+  public void onArrayIndexEnd(final Token<?> lookahead) {
 
 
   }
diff --git a/src/main/java/com/googlecode/aviator/code/OptimizeCodeGenerator.java b/src/main/java/com/googlecode/aviator/code/OptimizeCodeGenerator.java
index 29ef7f05..e9b316d0 100644
--- a/src/main/java/com/googlecode/aviator/code/OptimizeCodeGenerator.java
+++ b/src/main/java/com/googlecode/aviator/code/OptimizeCodeGenerator.java
@@ -319,36 +319,36 @@ private void compactTokenList() {
   }
 
 
-  private AviatorObject getAviatorObjectFromToken(final Token<?> lookhead) {
+  private AviatorObject getAviatorObjectFromToken(final Token<?> lookahead) {
     AviatorObject result = null;
-    switch (lookhead.getType()) {
+    switch (lookahead.getType()) {
       case Number:
         // load numbers
-        NumberToken numberToken = (NumberToken) lookhead;
+        NumberToken numberToken = (NumberToken) lookahead;
         Number num = numberToken.getNumber();
         result = AviatorNumber.valueOf(num);
         break;
       case String:
         // load string
         result =
-            new AviatorString((String) lookhead.getValue(null), true, true, lookhead.getLineNo());
+            new AviatorString((String) lookahead.getValue(null), true, true, lookahead.getLineNo());
         break;
       case Pattern:
         // load pattern
-        result = new AviatorPattern((String) lookhead.getValue(null));
+        result = new AviatorPattern((String) lookahead.getValue(null));
         break;
       case Variable:
-        if (lookhead == Variable.TRUE) {
+        if (lookahead == Variable.TRUE) {
           result = AviatorBoolean.TRUE;
-        } else if (lookhead == Variable.FALSE) {
+        } else if (lookahead == Variable.FALSE) {
           result = AviatorBoolean.FALSE;
-        } else if (lookhead == Variable.NIL) {
+        } else if (lookahead == Variable.NIL) {
           result = AviatorNil.NIL;
         }
         break;
       case Char:
-        result = new AviatorString(String.valueOf(lookhead.getValue(null)), true, true,
-            lookhead.getLineNo());
+        result = new AviatorString(String.valueOf(lookahead.getValue(null)), true, true,
+            lookahead.getLineNo());
         break;
     }
     return result;
@@ -617,151 +617,151 @@ private void printTokenList() {
 
 
   @Override
-  public void onAdd(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.ADD));
+  public void onAdd(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.ADD));
 
   }
 
 
   @Override
-  public void onAndLeft(final Token<?> lookhead) {
-    this.tokenList.add(new DelegateToken(lookhead, DelegateTokenType.And_Left));
+  public void onAndLeft(final Token<?> lookahead) {
+    this.tokenList.add(new DelegateToken(lookahead, DelegateTokenType.And_Left));
   }
 
 
   @Override
-  public void onAndRight(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.AND));
+  public void onAndRight(final Token<?> alookahead) {
+    this.tokenList.add(new OperatorToken(alookahead, OperatorType.AND));
 
   }
 
 
   @Override
-  public void onConstant(final Token<?> lookhead) {
-    this.tokenList.add(lookhead);
+  public void onConstant(final Token<?> lookahead) {
+    this.tokenList.add(lookahead);
   }
 
 
   @Override
-  public void onDiv(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.DIV));
+  public void onDiv(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.DIV));
 
   }
 
 
   @Override
-  public void onArrayIndexStart(final Token<?> lookhead) {
-    this.tokenList.add(new DelegateToken(lookhead, DelegateTokenType.Index_Start));
+  public void onArrayIndexStart(final Token<?> lookahead) {
+    this.tokenList.add(new DelegateToken(lookahead, DelegateTokenType.Index_Start));
 
   }
 
   @Override
-  public void onAssignment(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead,
-        (lookhead == null || !lookhead.getMeta(Constants.DEFINE_META, false))
+  public void onAssignment(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead,
+        (lookahead == null || !lookahead.getMeta(Constants.DEFINE_META, false))
             ? OperatorType.ASSIGNMENT
             : OperatorType.DEFINE));
   }
 
 
   @Override
-  public void onArrayIndexEnd(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.INDEX));
+  public void onArrayIndexEnd(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.INDEX));
   }
 
 
   @Override
-  public void onArray(final Token<?> lookhead) {
-    this.tokenList.add(new DelegateToken(lookhead, DelegateTokenType.Array));
+  public void onArray(final Token<?> lookahead) {
+    this.tokenList.add(new DelegateToken(lookahead, DelegateTokenType.Array));
 
   }
 
 
   @Override
-  public void onEq(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.EQ));
+  public void onEq(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.EQ));
 
   }
 
 
   @Override
-  public void onGe(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.GE));
+  public void onGe(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.GE));
 
   }
 
 
   @Override
-  public void onGt(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.GT));
+  public void onGt(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.GT));
 
   }
 
 
   @Override
-  public void onJoinLeft(final Token<?> lookhead) {
-    this.tokenList.add(new DelegateToken(lookhead, DelegateTokenType.Join_Left));
+  public void onJoinLeft(final Token<?> lookahead) {
+    this.tokenList.add(new DelegateToken(lookahead, DelegateTokenType.Join_Left));
   }
 
 
   @Override
-  public void onJoinRight(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.OR));
+  public void onJoinRight(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.OR));
 
   }
 
 
   @Override
-  public void onLe(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.LE));
+  public void onLe(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.LE));
 
   }
 
 
   @Override
-  public void onLt(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.LT));
+  public void onLt(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.LT));
 
   }
 
 
   @Override
-  public void onMatch(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.MATCH));
+  public void onMatch(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.MATCH));
 
   }
 
 
   @Override
-  public void onMethodInvoke(final Token<?> lookhead) {
-    OperatorToken token = new OperatorToken(lookhead, OperatorType.FUNC);
-    token.setMetaMap(lookhead != null ? lookhead.getMetaMap() : null);
+  public void onMethodInvoke(final Token<?> lookahead) {
+    OperatorToken token = new OperatorToken(lookahead, OperatorType.FUNC);
+    token.setMetaMap(lookahead != null ? lookahead.getMetaMap() : null);
     this.tokenList.add(token);
 
   }
 
 
   @Override
-  public void onMethodName(final Token<?> lookhead) {
-    this.tokenList.add(new DelegateToken(lookhead, DelegateTokenType.Method_Name));
+  public void onMethodName(final Token<?> lookahead) {
+    this.tokenList.add(new DelegateToken(lookahead, DelegateTokenType.Method_Name));
 
   }
 
 
   @Override
-  public void onMethodParameter(final Token<?> lookhead) {
-    this.tokenList.add(new DelegateToken(lookhead, DelegateTokenType.Method_Param));
+  public void onMethodParameter(final Token<?> lookahead) {
+    this.tokenList.add(new DelegateToken(lookahead, DelegateTokenType.Method_Param));
 
   }
 
 
 
   @Override
-  public void onLambdaDefineStart(final Token<?> lookhead) {
+  public void onLambdaDefineStart(final Token<?> lookahead) {
     if (this.lambdaGenerator == null) {
       // TODO cache?
-      Boolean newLexicalScope = lookhead.getMeta(Constants.SCOPE_META, false);
-      Boolean inheritEnv = lookhead.getMeta(Constants.INHERIT_ENV_META, false);
+      Boolean newLexicalScope = lookahead.getMeta(Constants.SCOPE_META, false);
+      Boolean inheritEnv = lookahead.getMeta(Constants.INHERIT_ENV_META, false);
       this.lambdaGenerator = new LambdaGenerator(this.instance, this, this.parser,
           this.codeGen.getClassLoader(), this.sourceFile, newLexicalScope, inheritEnv);
       this.lambdaGenerator.setScopeInfo(this.parser.enterScope(newLexicalScope));
@@ -772,27 +772,27 @@ public void onLambdaDefineStart(final Token<?> lookhead) {
 
 
   @Override
-  public void onLambdaArgument(final Token<?> lookhead, final FunctionParam param) {
+  public void onLambdaArgument(final Token<?> lookahead, final FunctionParam param) {
     this.lambdaGenerator.addParam(param);
   }
 
 
   @Override
-  public void onLambdaBodyStart(final Token<?> lookhead) {
+  public void onLambdaBodyStart(final Token<?> lookahead) {
     this.parentCodeGenerator = this.parser.getCodeGenerator();
     this.parser.setCodeGenerator(this.lambdaGenerator);
   }
 
 
   @Override
-  public void onLambdaBodyEnd(final Token<?> lookhead) {
+  public void onLambdaBodyEnd(final Token<?> lookahead) {
     // this.lambdaGenerator.compileCallMethod();
     LambdaFunctionBootstrap bootstrap = this.lambdaGenerator.getLmabdaBootstrap();
     if (this.lambdaBootstraps == null) {
       this.lambdaBootstraps = new HashMap<String, LambdaFunctionBootstrap>();
     }
     this.lambdaBootstraps.put(bootstrap.getName(), bootstrap);
-    DelegateToken token = new DelegateToken(lookhead, DelegateTokenType.Lambda_New);
+    DelegateToken token = new DelegateToken(lookahead, DelegateTokenType.Lambda_New);
     token.setLambdaFunctionBootstrap(bootstrap);
     this.tokenList.add(token);
     this.parser.restoreScope(this.lambdaGenerator.getScopeInfo());
@@ -802,122 +802,122 @@ public void onLambdaBodyEnd(final Token<?> lookhead) {
 
 
   @Override
-  public void onMod(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.MOD));
+  public void onMod(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.MOD));
 
   }
 
 
   @Override
-  public void onMult(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.MULT));
+  public void onMult(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.MULT));
 
   }
 
   @Override
-  public void onExponent(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.Exponent));
+  public void onExponent(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.Exponent));
 
   }
 
   @Override
-  public void onNeg(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.NEG));
+  public void onNeg(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.NEG));
 
   }
 
 
   @Override
-  public void onNeq(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.NEQ));
+  public void onNeq(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.NEQ));
 
   }
 
 
   @Override
-  public void onNot(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.NOT));
+  public void onNot(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.NOT));
 
   }
 
 
   @Override
-  public void onSub(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.SUB));
+  public void onSub(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.SUB));
 
   }
 
 
   @Override
-  public void onTernaryBoolean(final Token<?> lookhead) {
-    this.tokenList.add(new DelegateToken(lookhead, DelegateTokenType.Ternary_Boolean));
+  public void onTernaryBoolean(final Token<?> lookahead) {
+    this.tokenList.add(new DelegateToken(lookahead, DelegateTokenType.Ternary_Boolean));
 
   }
 
 
   @Override
-  public void onTernaryLeft(final Token<?> lookhead) {
-    this.tokenList.add(new DelegateToken(lookhead, DelegateTokenType.Ternary_Left));
+  public void onTernaryLeft(final Token<?> lookahead) {
+    this.tokenList.add(new DelegateToken(lookahead, DelegateTokenType.Ternary_Left));
 
   }
 
 
   @Override
-  public void onTernaryRight(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.TERNARY));
+  public void onTernaryRight(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.TERNARY));
   }
 
 
   @Override
-  public void onTernaryEnd(final Token<?> lookhead) {
-    this.tokenList.add(new DelegateToken(lookhead, DelegateTokenType.Ternay_End));
+  public void onTernaryEnd(final Token<?> lookahead) {
+    this.tokenList.add(new DelegateToken(lookahead, DelegateTokenType.Ternay_End));
   }
 
 
   @Override
-  public void onBitAnd(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.BIT_AND));
+  public void onBitAnd(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.BIT_AND));
 
   }
 
 
   @Override
-  public void onBitNot(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.BIT_NOT));
+  public void onBitNot(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.BIT_NOT));
   }
 
 
   @Override
-  public void onBitOr(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.BIT_OR));
+  public void onBitOr(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.BIT_OR));
 
   }
 
 
   @Override
-  public void onShiftLeft(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.SHIFT_LEFT));
+  public void onShiftLeft(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.SHIFT_LEFT));
 
   }
 
 
   @Override
-  public void onShiftRight(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.SHIFT_RIGHT));
+  public void onShiftRight(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.SHIFT_RIGHT));
 
   }
 
 
   @Override
-  public void onUnsignedShiftRight(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.U_SHIFT_RIGHT));
+  public void onUnsignedShiftRight(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.U_SHIFT_RIGHT));
 
   }
 
 
   @Override
-  public void onBitXor(final Token<?> lookhead) {
-    this.tokenList.add(new OperatorToken(lookhead, OperatorType.BIT_XOR));
+  public void onBitXor(final Token<?> lookahead) {
+    this.tokenList.add(new OperatorToken(lookahead, OperatorType.BIT_XOR));
 
   }
 
diff --git a/src/main/java/com/googlecode/aviator/code/asm/ASMCodeGenerator.java b/src/main/java/com/googlecode/aviator/code/asm/ASMCodeGenerator.java
index de5e5171..cae88d0d 100644
--- a/src/main/java/com/googlecode/aviator/code/asm/ASMCodeGenerator.java
+++ b/src/main/java/com/googlecode/aviator/code/asm/ASMCodeGenerator.java
@@ -292,8 +292,8 @@ private Label makeLabel() {
    * @see com.googlecode.aviator.code.CodeGenerator#onAdd(com.googlecode.aviator .lexer.token.Token)
    */
   @Override
-  public void onAdd(final Token<?> lookhead) {
-    visitBinOperator(lookhead, OperatorType.ADD, "add");
+  public void onAdd(final Token<?> lookahead) {
+    visitBinOperator(lookahead, OperatorType.ADD, "add");
   }
 
   private void loadOpType(final OperatorType opType) {
@@ -322,8 +322,8 @@ private void popOperand(final int n) {
    * @see com.googlecode.aviator.code.CodeGenerator#onSub(com.googlecode.aviator .lexer.token.Token)
    */
   @Override
-  public void onSub(final Token<?> lookhead) {
-    visitBinOperator(lookhead, OperatorType.SUB, "sub");
+  public void onSub(final Token<?> lookahead) {
+    visitBinOperator(lookahead, OperatorType.SUB, "sub");
   }
 
   /*
@@ -333,19 +333,19 @@ public void onSub(final Token<?> lookhead) {
    * .lexer.token.Token)
    */
   @Override
-  public void onMult(final Token<?> lookhead) {
-    visitBinOperator(lookhead, OperatorType.MULT, "mult");
+  public void onMult(final Token<?> lookahead) {
+    visitBinOperator(lookahead, OperatorType.MULT, "mult");
   }
 
   @Override
-  public void onExponent(final Token<?> lookhead) {
-    visitBinOperator(lookhead, OperatorType.Exponent, "exponent");
+  public void onExponent(final Token<?> lookahead) {
+    visitBinOperator(lookahead, OperatorType.Exponent, "exponent");
   }
 
   @Override
-  public void onAssignment(final Token<?> lookhead) {
-    visitLineNumber(lookhead);
-    OperatorType opType = lookhead.getMeta(Constants.DEFINE_META, false) ? OperatorType.DEFINE
+  public void onAssignment(final Token<?> lookahead) {
+    visitLineNumber(lookahead);
+    OperatorType opType = lookahead.getMeta(Constants.DEFINE_META, false) ? OperatorType.DEFINE
         : OperatorType.ASSIGNMENT;
     loadEnv();
     if (!OperationRuntime.hasRuntimeContext(this.compileEnv, opType)) {
@@ -369,8 +369,8 @@ public void onAssignment(final Token<?> lookhead) {
    * @see com.googlecode.aviator.code.CodeGenerator#onDiv(com.googlecode.aviator .lexer.token.Token)
    */
   @Override
-  public void onDiv(final Token<?> lookhead) {
-    visitBinOperator(lookhead, OperatorType.DIV, "div");
+  public void onDiv(final Token<?> lookahead) {
+    visitBinOperator(lookahead, OperatorType.DIV, "div");
   }
 
   /*
@@ -379,17 +379,17 @@ public void onDiv(final Token<?> lookhead) {
    * @see com.googlecode.aviator.code.CodeGenerator#onMod(com.googlecode.aviator .lexer.token.Token)
    */
   @Override
-  public void onMod(final Token<?> lookhead) {
-    visitBinOperator(lookhead, OperatorType.MOD, "mod");
+  public void onMod(final Token<?> lookahead) {
+    visitBinOperator(lookahead, OperatorType.MOD, "mod");
   }
 
   /**
    * Do logic operation "&&" left operand
    */
   @Override
-  public void onAndLeft(final Token<?> lookhead) {
+  public void onAndLeft(final Token<?> lookahead) {
     loadEnv();
-    visitLeftBranch(lookhead, IFEQ, OperatorType.AND);
+    visitLeftBranch(lookahead, IFEQ, OperatorType.AND);
   }
 
   private void visitBoolean() {
@@ -404,13 +404,13 @@ private void pushLabel0(final Label l0) {
    * Do logic operation "&&" right operand
    */
   @Override
-  public void onAndRight(final Token<?> lookhead) {
-    visitRightBranch(lookhead, IFEQ, OperatorType.AND);
+  public void onAndRight(final Token<?> lookahead) {
+    visitRightBranch(lookahead, IFEQ, OperatorType.AND);
     this.popOperand(2); // boolean object and environment
     this.pushOperand();
   }
 
-  private void visitRightBranch(final Token<?> lookhead, final int ints,
+  private void visitRightBranch(final Token<?> lookahead, final int ints,
       final OperatorType opType) {
     this.checkExecutionTimeout();
     if (!OperationRuntime.hasRuntimeContext(this.compileEnv, opType)) {
@@ -425,7 +425,7 @@ private void visitRightBranch(final Token<?> lookhead, final int ints,
       this.mv.visitInsn(POP);
 
       Label l1 = makeLabel();
-      visitLineNumber(lookhead);
+      visitLineNumber(lookahead);
       this.mv.visitJumpInsn(GOTO, l1);
       visitLabel(popLabel0());
       // Result is false
@@ -434,7 +434,7 @@ private void visitRightBranch(final Token<?> lookhead, final int ints,
       visitLabel(l1);
     } else {
       loadOpType(opType);
-      visitLineNumber(lookhead);
+      visitLineNumber(lookahead);
       this.mv.visitMethodInsn(INVOKESTATIC, "com/googlecode/aviator/runtime/op/OperationRuntime",
           "eval",
           "(Lcom/googlecode/aviator/runtime/type/AviatorObject;Ljava/util/Map;Lcom/googlecode/aviator/runtime/type/AviatorObject;Lcom/googlecode/aviator/lexer/token/OperatorType;)Lcom/googlecode/aviator/runtime/type/AviatorObject;");
@@ -449,9 +449,9 @@ private void visitRightBranch(final Token<?> lookhead, final int ints,
   private final Stack<Label> l1stack = new Stack<Label>();
 
   @Override
-  public void onTernaryBoolean(final Token<?> lookhead) {
+  public void onTernaryBoolean(final Token<?> lookahead) {
     loadEnv();
-    visitLineNumber(lookhead);
+    visitLineNumber(lookahead);
     checkExecutionTimeout();
     visitBoolean();
     Label l0 = makeLabel();
@@ -471,11 +471,11 @@ private void pushLabel1(final Label l1) {
   }
 
   @Override
-  public void onTernaryLeft(final Token<?> lookhead) {
+  public void onTernaryLeft(final Token<?> lookahead) {
     checkExecutionTimeout();
     this.mv.visitJumpInsn(GOTO, peekLabel1());
     visitLabel(popLabel0());
-    visitLineNumber(lookhead);
+    visitLineNumber(lookahead);
     this.popOperand(); // pop one boolean
   }
 
@@ -484,16 +484,16 @@ private Label peekLabel1() {
   }
 
   @Override
-  public void onTernaryRight(final Token<?> lookhead) {
+  public void onTernaryRight(final Token<?> lookahead) {
     checkExecutionTimeout();
     visitLabel(popLabel1());
-    visitLineNumber(lookhead);
+    visitLineNumber(lookahead);
     this.popOperand(); // pop one boolean
   }
 
   @Override
-  public void onTernaryEnd(final Token<?> lookhead) {
-    visitLineNumber(lookhead);
+  public void onTernaryEnd(final Token<?> lookahead) {
+    visitLineNumber(lookahead);
     if (this.operandsCount == 0) {
       return;
     }
@@ -510,8 +510,8 @@ private Label popLabel1() {
    * Do logic operation "||" right operand
    */
   @Override
-  public void onJoinRight(final Token<?> lookhead) {
-    visitRightBranch(lookhead, IFNE, OperatorType.OR);
+  public void onJoinRight(final Token<?> lookahead) {
+    visitRightBranch(lookahead, IFNE, OperatorType.OR);
     this.popOperand(2);
     this.pushOperand();
 
@@ -534,18 +534,18 @@ private Label popLabel0() {
    * Do logic operation "||" left operand
    */
   @Override
-  public void onJoinLeft(final Token<?> lookhead) {
+  public void onJoinLeft(final Token<?> lookahead) {
     loadEnv();
-    visitLeftBranch(lookhead, IFNE, OperatorType.OR);
+    visitLeftBranch(lookahead, IFNE, OperatorType.OR);
   }
 
-  private void visitLeftBranch(final Token<?> lookhead, final int ints, final OperatorType opType) {
+  private void visitLeftBranch(final Token<?> lookahead, final int ints, final OperatorType opType) {
     this.checkExecutionTimeout();
     if (!OperationRuntime.hasRuntimeContext(this.compileEnv, opType)) {
       visitBoolean();
       Label l0 = makeLabel();
       pushLabel0(l0);
-      visitLineNumber(lookhead);
+      visitLineNumber(lookahead);
       this.mv.visitJumpInsn(ints, l0);
       this.popOperand();
     }
@@ -553,26 +553,26 @@ private void visitLeftBranch(final Token<?> lookhead, final int ints, final Oper
   }
 
   @Override
-  public void onEq(final Token<?> lookhead) {
-    doCompareAndJump(lookhead, IFNE, OperatorType.EQ);
+  public void onEq(final Token<?> lookahead) {
+    doCompareAndJump(lookahead, IFNE, OperatorType.EQ);
   }
 
   @Override
-  public void onMatch(final Token<?> lookhead) {
-    visitLineNumber(lookhead);
-    visitBinOperator(lookhead, OperatorType.MATCH, "match");
+  public void onMatch(final Token<?> lookahead) {
+    visitLineNumber(lookahead);
+    visitBinOperator(lookahead, OperatorType.MATCH, "match");
     this.popOperand();
     this.pushOperand();
   }
 
   @Override
-  public void onNeq(final Token<?> lookhead) {
-    doCompareAndJump(lookhead, IFEQ, OperatorType.NEQ);
+  public void onNeq(final Token<?> lookahead) {
+    doCompareAndJump(lookahead, IFEQ, OperatorType.NEQ);
   }
 
-  private void doCompareAndJump(final Token<?> lookhead, final int ints,
+  private void doCompareAndJump(final Token<?> lookahead, final int ints,
       final OperatorType opType) {
-    visitLineNumber(lookhead);
+    visitLineNumber(lookahead);
     this.checkExecutionTimeout();
     loadEnv();
     visitCompare(ints, opType);
@@ -609,24 +609,24 @@ private void visitCompare(final int ints, final OperatorType opType) {
   }
 
   @Override
-  public void onGe(final Token<?> lookhead) {
-    doCompareAndJump(lookhead, IFLT, OperatorType.GE);
+  public void onGe(final Token<?> lookahead) {
+    doCompareAndJump(lookahead, IFLT, OperatorType.GE);
   }
 
   @Override
-  public void onGt(final Token<?> lookhead) {
-    doCompareAndJump(lookhead, IFLE, OperatorType.GT);
+  public void onGt(final Token<?> lookahead) {
+    doCompareAndJump(lookahead, IFLE, OperatorType.GT);
   }
 
   @Override
-  public void onLe(final Token<?> lookhead) {
-    doCompareAndJump(lookhead, IFGT, OperatorType.LE);
+  public void onLe(final Token<?> lookahead) {
+    doCompareAndJump(lookahead, IFGT, OperatorType.LE);
 
   }
 
   @Override
-  public void onLt(final Token<?> lookhead) {
-    doCompareAndJump(lookhead, IFGE, OperatorType.LT);
+  public void onLt(final Token<?> lookahead) {
+    doCompareAndJump(lookahead, IFGE, OperatorType.LT);
   }
 
   private void pushOperand(final int delta) {
@@ -638,8 +638,8 @@ private void pushOperand(final int delta) {
    * Logic operation '!'
    */
   @Override
-  public void onNot(final Token<?> lookhead) {
-    visitUnaryOperator(lookhead, OperatorType.NOT, "not");
+  public void onNot(final Token<?> lookahead) {
+    visitUnaryOperator(lookahead, OperatorType.NOT, "not");
   }
 
   private void visitBinOperator(final Token<?> token, final OperatorType opType,
@@ -672,9 +672,9 @@ private void visitLineNumber(final Token<?> token) {
     }
   }
 
-  private void visitUnaryOperator(final Token<?> lookhead, final OperatorType opType,
+  private void visitUnaryOperator(final Token<?> lookahead, final OperatorType opType,
       final String methodName) {
-    visitLineNumber(lookhead);
+    visitLineNumber(lookahead);
     this.mv.visitTypeInsn(CHECKCAST, OBJECT_OWNER);
     loadEnv();
 
@@ -696,8 +696,8 @@ private void visitUnaryOperator(final Token<?> lookhead, final OperatorType opTy
    * Bit operation '~'
    */
   @Override
-  public void onBitNot(final Token<?> lookhead) {
-    visitUnaryOperator(lookhead, OperatorType.BIT_NOT, "bitNot");
+  public void onBitNot(final Token<?> lookahead) {
+    visitUnaryOperator(lookahead, OperatorType.BIT_NOT, "bitNot");
   }
 
   /*
@@ -707,8 +707,8 @@ public void onBitNot(final Token<?> lookhead) {
    * int)
    */
   @Override
-  public void onNeg(final Token<?> lookhead) {
-    visitUnaryOperator(lookhead, OperatorType.NEG, "neg");
+  public void onNeg(final Token<?> lookahead) {
+    visitUnaryOperator(lookahead, OperatorType.NEG, "neg");
   }
 
   /*
@@ -855,24 +855,24 @@ private void end(final boolean unboxObject) {
    * .lexer.token.Token)
    */
   @Override
-  public void onConstant(final Token<?> lookhead) {
-    onConstant0(lookhead, false);
+  public void onConstant(final Token<?> lookahead) {
+    onConstant0(lookahead, false);
   }
 
-  private void onConstant0(final Token<?> lookhead, final boolean inConstructor) {
-    if (lookhead == null) {
+  private void onConstant0(final Token<?> lookahead, final boolean inConstructor) {
+    if (lookahead == null) {
       return;
     }
-    visitLineNumber(lookhead);
+    visitLineNumber(lookahead);
     // load token to stack
-    switch (lookhead.getType()) {
+    switch (lookahead.getType()) {
       case Number:
-        if (loadConstant(lookhead, inConstructor)) {
+        if (loadConstant(lookahead, inConstructor)) {
           return;
         }
 
         // load numbers
-        NumberToken numberToken = (NumberToken) lookhead;
+        NumberToken numberToken = (NumberToken) lookahead;
         Number number = numberToken.getNumber();
 
         if (TypeUtils.isBigInt(number)) {
@@ -907,29 +907,29 @@ private void onConstant0(final Token<?> lookhead, final boolean inConstructor) {
         // this.popOperand();
         break;
       case String:
-        if (loadConstant(lookhead, inConstructor)) {
+        if (loadConstant(lookahead, inConstructor)) {
           return;
         }
         // load string
         this.mv.visitTypeInsn(NEW, "com/googlecode/aviator/runtime/type/AviatorString");
         this.mv.visitInsn(DUP);
-        this.mv.visitLdcInsn(lookhead.getValue(null));
+        this.mv.visitLdcInsn(lookahead.getValue(null));
         this.mv.visitLdcInsn(true);
-        this.mv.visitLdcInsn(lookhead.getMeta(Constants.INTER_META, true));
-        this.mv.visitLdcInsn(lookhead.getLineNo());
+        this.mv.visitLdcInsn(lookahead.getMeta(Constants.INTER_META, true));
+        this.mv.visitLdcInsn(lookahead.getLineNo());
         this.mv.visitMethodInsn(INVOKESPECIAL, "com/googlecode/aviator/runtime/type/AviatorString",
             CONSTRUCTOR_METHOD_NAME, "(Ljava/lang/String;ZZI)V");
         this.pushOperand(6);
         this.popOperand(5);
         break;
       case Pattern:
-        if (loadConstant(lookhead, inConstructor)) {
+        if (loadConstant(lookahead, inConstructor)) {
           return;
         }
         // load pattern
         this.mv.visitTypeInsn(NEW, "com/googlecode/aviator/runtime/type/AviatorPattern");
         this.mv.visitInsn(DUP);
-        this.mv.visitLdcInsn(lookhead.getValue(null));
+        this.mv.visitLdcInsn(lookahead.getValue(null));
         this.mv.visitMethodInsn(INVOKESPECIAL, "com/googlecode/aviator/runtime/type/AviatorPattern",
             CONSTRUCTOR_METHOD_NAME, "(Ljava/lang/String;)V");
         this.pushOperand(3);
@@ -937,7 +937,7 @@ private void onConstant0(final Token<?> lookhead, final boolean inConstructor) {
         break;
       case Variable:
         // load variable
-        Variable variable = (Variable) lookhead;
+        Variable variable = (Variable) lookahead;
 
         if (variable.equals(Variable.TRUE)) {
           this.mv.visitFieldInsn(GETSTATIC, "com/googlecode/aviator/runtime/type/AviatorBoolean",
@@ -999,9 +999,9 @@ private void onConstant0(final Token<?> lookhead, final boolean inConstructor) {
     }
   }
 
-  private boolean loadConstant(final Token<?> lookhead, final boolean inConstructor) {
+  private boolean loadConstant(final Token<?> lookahead, final boolean inConstructor) {
     String fieldName;
-    if (!inConstructor && (fieldName = this.constantPool.get(lookhead)) != null) {
+    if (!inConstructor && (fieldName = this.constantPool.get(lookahead)) != null) {
       this.mv.visitVarInsn(ALOAD, 0);
       this.mv.visitFieldInsn(GETFIELD, this.className, fieldName, OBJECT_DESC);
       this.pushOperand();
@@ -1081,11 +1081,11 @@ private static String getInvokeMethodDesc(final int paramCount) {
   }
 
   @Override
-  public void onMethodInvoke(final Token<?> lookhead) {
-    visitLineNumber(lookhead);
+  public void onMethodInvoke(final Token<?> lookahead) {
+    visitLineNumber(lookahead);
     @SuppressWarnings("unchecked")
-    final List<FunctionArgument> params = lookhead != null
-        ? (List<FunctionArgument>) lookhead.getMeta(Constants.PARAMS_META, Collections.EMPTY_LIST)
+    final List<FunctionArgument> params = lookahead != null
+        ? (List<FunctionArgument>) lookahead.getMeta(Constants.PARAMS_META, Collections.EMPTY_LIST)
         : Collections.EMPTY_LIST;
 
     if (this.instance.getOptionValue(Options.CAPTURE_FUNCTION_ARGS).bool) {
@@ -1149,8 +1149,8 @@ public void onMethodInvoke(final Token<?> lookhead) {
   }
 
   @Override
-  public void onMethodParameter(final Token<?> lookhead) {
-    visitLineNumber(lookhead);
+  public void onMethodParameter(final Token<?> lookahead) {
+    visitLineNumber(lookahead);
     MethodMetaData currentMethodMetaData = this.methodMetaDataStack.peek();
     if (currentMethodMetaData.parameterCount >= 20) {
       // Add last param to variadic param list
@@ -1209,8 +1209,8 @@ public MethodMetaData(final Token<?> token, final String methodName) {
   }
 
   @Override
-  public void onArray(final Token<?> lookhead) {
-    onConstant(lookhead);
+  public void onArray(final Token<?> lookahead) {
+    onConstant(lookahead);
   }
 
   @Override
@@ -1219,8 +1219,8 @@ public void onArrayIndexStart(final Token<?> token) {
   }
 
   @Override
-  public void onArrayIndexEnd(final Token<?> lookhead) {
-    visitLineNumber(lookhead);
+  public void onArrayIndexEnd(final Token<?> lookahead) {
+    visitLineNumber(lookahead);
     if (!OperationRuntime.hasRuntimeContext(this.compileEnv, OperatorType.INDEX)) {
       this.mv.visitMethodInsn(INVOKEVIRTUAL, OBJECT_OWNER, "getElement",
           "(Ljava/util/Map;Lcom/googlecode/aviator/runtime/type/AviatorObject;)Lcom/googlecode/aviator/runtime/type/AviatorObject;");
@@ -1241,10 +1241,10 @@ public int getLocalIndex() {
   }
 
   @Override
-  public void onLambdaDefineStart(final Token<?> lookhead) {
+  public void onLambdaDefineStart(final Token<?> lookahead) {
     if (this.lambdaGenerator == null) {
-      Boolean newLexicalScope = lookhead.getMeta(Constants.SCOPE_META, false);
-      Boolean inheritEnv = lookhead.getMeta(Constants.INHERIT_ENV_META, false);
+      Boolean newLexicalScope = lookahead.getMeta(Constants.SCOPE_META, false);
+      Boolean inheritEnv = lookahead.getMeta(Constants.INHERIT_ENV_META, false);
       // TODO cache?
       this.lambdaGenerator = new LambdaGenerator(this.instance, this, this.parser, this.classLoader,
           this.sourceFile, newLexicalScope, inheritEnv);
@@ -1255,18 +1255,18 @@ public void onLambdaDefineStart(final Token<?> lookhead) {
   }
 
   @Override
-  public void onLambdaArgument(final Token<?> lookhead, final FunctionParam param) {
+  public void onLambdaArgument(final Token<?> lookahead, final FunctionParam param) {
     this.lambdaGenerator.addParam(param);
   }
 
   @Override
-  public void onLambdaBodyStart(final Token<?> lookhead) {
+  public void onLambdaBodyStart(final Token<?> lookahead) {
     this.parentCodeGenerator = this.parser.getCodeGenerator();
     this.parser.setCodeGenerator(this.lambdaGenerator);
   }
 
   @Override
-  public void onLambdaBodyEnd(final Token<?> lookhead) {
+  public void onLambdaBodyEnd(final Token<?> lookahead) {
     // this.lambdaGenerator.compileCallMethod();
     LambdaFunctionBootstrap bootstrap = this.lambdaGenerator.getLmabdaBootstrap();
     if (this.lambdaBootstraps == null) {
@@ -1274,7 +1274,7 @@ public void onLambdaBodyEnd(final Token<?> lookhead) {
       this.lambdaBootstraps = new LinkedHashMap<String, LambdaFunctionBootstrap>();
     }
     this.lambdaBootstraps.put(bootstrap.getName(), bootstrap);
-    visitLineNumber(lookhead);
+    visitLineNumber(lookahead);
     genNewLambdaCode(bootstrap);
     this.parser.restoreScope(this.lambdaGenerator.getScopeInfo());
     this.lambdaGenerator = null;
@@ -1293,13 +1293,13 @@ public void genNewLambdaCode(final LambdaFunctionBootstrap bootstrap) {
   }
 
   @Override
-  public void onMethodName(final Token<?> lookhead) {
+  public void onMethodName(final Token<?> lookahead) {
 
     checkExecutionTimeout();
 
     String outtterMethodName = "lambda";
-    if (lookhead.getType() != TokenType.Delegate) {
-      outtterMethodName = lookhead.getLexeme();
+    if (lookahead.getType() != TokenType.Delegate) {
+      outtterMethodName = lookahead.getLexeme();
       String innerMethodName = this.innerMethodMap.get(outtterMethodName);
       if (innerMethodName != null) {
         loadAviatorFunction(outtterMethodName, innerMethodName);
@@ -1318,13 +1318,13 @@ public void onMethodName(final Token<?> lookhead) {
           "(Lcom/googlecode/aviator/runtime/type/AviatorFunction;)Lcom/googlecode/aviator/runtime/type/AviatorFunction;");
     }
     // FIXME it will not work in compile mode.
-    if (lookhead.getMeta(Constants.UNPACK_ARGS, false)) {
+    if (lookahead.getMeta(Constants.UNPACK_ARGS, false)) {
       this.mv.visitMethodInsn(INVOKESTATIC, RUNTIME_UTILS, "unpackArgsFunction",
           "(Lcom/googlecode/aviator/runtime/type/AviatorFunction;)Lcom/googlecode/aviator/runtime/type/AviatorFunction;");
     }
 
     loadEnv();
-    this.methodMetaDataStack.push(new MethodMetaData(lookhead, outtterMethodName));
+    this.methodMetaDataStack.push(new MethodMetaData(lookahead, outtterMethodName));
   }
 
   private void checkExecutionTimeout() {
@@ -1380,35 +1380,35 @@ private void createAviatorFunctionObject(final String methodName) {
   }
 
   @Override
-  public void onBitAnd(final Token<?> lookhead) {
-    visitBinOperator(lookhead, OperatorType.BIT_AND, "bitAnd");
+  public void onBitAnd(final Token<?> lookahead) {
+    visitBinOperator(lookahead, OperatorType.BIT_AND, "bitAnd");
   }
 
   @Override
-  public void onBitOr(final Token<?> lookhead) {
-    visitBinOperator(lookhead, OperatorType.BIT_OR, "bitOr");
+  public void onBitOr(final Token<?> lookahead) {
+    visitBinOperator(lookahead, OperatorType.BIT_OR, "bitOr");
   }
 
   @Override
-  public void onBitXor(final Token<?> lookhead) {
-    visitBinOperator(lookhead, OperatorType.BIT_XOR, "bitXor");
+  public void onBitXor(final Token<?> lookahead) {
+    visitBinOperator(lookahead, OperatorType.BIT_XOR, "bitXor");
   }
 
   @Override
-  public void onShiftLeft(final Token<?> lookhead) {
-    visitBinOperator(lookhead, OperatorType.SHIFT_LEFT, "shiftLeft");
+  public void onShiftLeft(final Token<?> lookahead) {
+    visitBinOperator(lookahead, OperatorType.SHIFT_LEFT, "shiftLeft");
 
   }
 
   @Override
-  public void onShiftRight(final Token<?> lookhead) {
-    visitBinOperator(lookhead, OperatorType.SHIFT_RIGHT, "shiftRight");
+  public void onShiftRight(final Token<?> lookahead) {
+    visitBinOperator(lookahead, OperatorType.SHIFT_RIGHT, "shiftRight");
 
   }
 
   @Override
-  public void onUnsignedShiftRight(final Token<?> lookhead) {
-    visitBinOperator(lookhead, OperatorType.U_SHIFT_RIGHT, "unsignedShiftRight");
+  public void onUnsignedShiftRight(final Token<?> lookahead) {
+    visitBinOperator(lookahead, OperatorType.U_SHIFT_RIGHT, "unsignedShiftRight");
 
   }
 
diff --git a/src/main/java/com/googlecode/aviator/code/interpreter/InterpretCodeGenerator.java b/src/main/java/com/googlecode/aviator/code/interpreter/InterpretCodeGenerator.java
index e680d500..dc28d606 100644
--- a/src/main/java/com/googlecode/aviator/code/interpreter/InterpretCodeGenerator.java
+++ b/src/main/java/com/googlecode/aviator/code/interpreter/InterpretCodeGenerator.java
@@ -129,8 +129,8 @@ public InterpretCodeGenerator(final AviatorEvaluatorInstance instance, final Str
   }
 
   @Override
-  public void onAssignment(final Token<?> lookhead) {
-    if (lookhead.getMeta(Constants.DEFINE_META, false)) {
+  public void onAssignment(final Token<?> lookahead) {
+    if (lookahead.getMeta(Constants.DEFINE_META, false)) {
       emit(OperatorIR.DEF);
     } else {
       emit(OperatorIR.ASSIGN);
@@ -138,53 +138,53 @@ public void onAssignment(final Token<?> lookhead) {
   }
 
   @Override
-  public void onShiftRight(final Token<?> lookhead) {
+  public void onShiftRight(final Token<?> lookahead) {
     emit(OperatorIR.SHIFT_RIGHT);
   }
 
   @Override
-  public void onShiftLeft(final Token<?> lookhead) {
+  public void onShiftLeft(final Token<?> lookahead) {
     emit(OperatorIR.SHIFT_LEFT);
   }
 
   @Override
-  public void onUnsignedShiftRight(final Token<?> lookhead) {
+  public void onUnsignedShiftRight(final Token<?> lookahead) {
     emit(OperatorIR.UNSIGNED_SHIFT_RIGHT);
   }
 
   @Override
-  public void onBitOr(final Token<?> lookhead) {
+  public void onBitOr(final Token<?> lookahead) {
     emit(OperatorIR.BIT_OR);
   }
 
   @Override
-  public void onBitAnd(final Token<?> lookhead) {
+  public void onBitAnd(final Token<?> lookahead) {
     emit(OperatorIR.BIT_AND);
   }
 
   @Override
-  public void onBitXor(final Token<?> lookhead) {
+  public void onBitXor(final Token<?> lookahead) {
     emit(OperatorIR.BIT_XOR);
   }
 
   @Override
-  public void onBitNot(final Token<?> lookhead) {
+  public void onBitNot(final Token<?> lookahead) {
     emit(OperatorIR.BIT_NOT);
   }
 
   @Override
-  public void onAdd(final Token<?> lookhead) {
+  public void onAdd(final Token<?> lookahead) {
     emit(OperatorIR.ADD);
   }
 
   @Override
-  public void onSub(final Token<?> lookhead) {
+  public void onSub(final Token<?> lookahead) {
     emit(OperatorIR.SUB);
 
   }
 
   @Override
-  public void onMult(final Token<?> lookhead) {
+  public void onMult(final Token<?> lookahead) {
     emit(OperatorIR.MULT);
   }
 
@@ -194,19 +194,19 @@ public void onExponent(final Token<?> loohead) {
   }
 
   @Override
-  public void onDiv(final Token<?> lookhead) {
+  public void onDiv(final Token<?> lookahead) {
     emit(OperatorIR.DIV);
 
   }
 
   @Override
-  public void onAndLeft(final Token<?> lookhead) {
+  public void onAndLeft(final Token<?> lookahead) {
     if (!OperationRuntime.containsOpFunction(this.compileEnv, OperatorType.AND)) {
       emit(new AssertTypeIR(AssertTypes.Bool));
       Label label = makeLabel();
       pushLabel0(label);
       this.instruments
-          .add(new BranchUnlessIR(label, new SourceInfo(this.sourceFile, lookhead.getLineNo())));
+          .add(new BranchUnlessIR(label, new SourceInfo(this.sourceFile, lookahead.getLineNo())));
       emit(PopIR.INSTANCE);
     }
   }
@@ -226,7 +226,7 @@ private void emit(IR ir) {
   }
 
   @Override
-  public void onAndRight(final Token<?> lookhead) {
+  public void onAndRight(final Token<?> alookahead) {
     if (!OperationRuntime.containsOpFunction(this.compileEnv, OperatorType.AND)) {
       emit(new AssertTypeIR(AssertTypes.Bool));
       Label label = popLabel0();
@@ -237,20 +237,20 @@ public void onAndRight(final Token<?> lookhead) {
   }
 
   @Override
-  public void onTernaryBoolean(final Token<?> lookhead) {
+  public void onTernaryBoolean(final Token<?> lookahead) {
     Label label0 = makeLabel();
     pushLabel0(label0);
     Label label1 = makeLabel();
     pushLabel1(label1);
     this.instruments
-        .add(new BranchUnlessIR(label0, new SourceInfo(this.sourceFile, lookhead.getLineNo())));
+        .add(new BranchUnlessIR(label0, new SourceInfo(this.sourceFile, lookahead.getLineNo())));
     emit(PopIR.INSTANCE);
   }
 
   @Override
-  public void onTernaryLeft(final Token<?> lookhead) {
+  public void onTernaryLeft(final Token<?> lookahead) {
     this.instruments
-        .add(new GotoIR(peekLabel1(), new SourceInfo(this.sourceFile, lookhead.getLineNo())));
+        .add(new GotoIR(peekLabel1(), new SourceInfo(this.sourceFile, lookahead.getLineNo())));
 
     // emit(PopIR.INSTANCE);
     Label label0 = popLabel0();
@@ -259,30 +259,30 @@ public void onTernaryLeft(final Token<?> lookhead) {
   }
 
   @Override
-  public void onTernaryRight(final Token<?> lookhead) {
+  public void onTernaryRight(final Token<?> lookahead) {
     Label label1 = popLabel1();
     visitLabel(label1);
   }
 
   @Override
-  public void onTernaryEnd(final Token<?> lookhead) {
+  public void onTernaryEnd(final Token<?> lookahead) {
     emit(ClearIR.INSTANCE);
   }
 
   @Override
-  public void onJoinLeft(final Token<?> lookhead) {
+  public void onJoinLeft(final Token<?> lookahead) {
     if (!OperationRuntime.containsOpFunction(this.compileEnv, OperatorType.AND)) {
       emit(new AssertTypeIR(AssertTypes.Bool));
       Label label = makeLabel();
       pushLabel0(label);
       this.instruments
-          .add(new BranchIfIR(label, new SourceInfo(this.sourceFile, lookhead.getLineNo())));
+          .add(new BranchIfIR(label, new SourceInfo(this.sourceFile, lookahead.getLineNo())));
       emit(PopIR.INSTANCE);
     }
   }
 
   @Override
-  public void onJoinRight(final Token<?> lookhead) {
+  public void onJoinRight(final Token<?> lookahead) {
     if (!OperationRuntime.containsOpFunction(this.compileEnv, OperatorType.AND)) {
       emit(new AssertTypeIR(AssertTypes.Bool));
       Label label = popLabel0();
@@ -293,52 +293,52 @@ public void onJoinRight(final Token<?> lookhead) {
   }
 
   @Override
-  public void onEq(final Token<?> lookhead) {
+  public void onEq(final Token<?> lookahead) {
     emit(OperatorIR.EQ);
   }
 
   @Override
-  public void onMatch(final Token<?> lookhead) {
+  public void onMatch(final Token<?> lookahead) {
     emit(OperatorIR.MATCH);
   }
 
   @Override
-  public void onNeq(final Token<?> lookhead) {
+  public void onNeq(final Token<?> lookahead) {
     emit(OperatorIR.NE);
   }
 
   @Override
-  public void onLt(final Token<?> lookhead) {
+  public void onLt(final Token<?> lookahead) {
     emit(OperatorIR.LT);
   }
 
   @Override
-  public void onLe(final Token<?> lookhead) {
+  public void onLe(final Token<?> lookahead) {
     emit(OperatorIR.LE);
   }
 
   @Override
-  public void onGt(final Token<?> lookhead) {
+  public void onGt(final Token<?> lookahead) {
     emit(OperatorIR.GT);
   }
 
   @Override
-  public void onGe(final Token<?> lookhead) {
+  public void onGe(final Token<?> lookahead) {
     emit(OperatorIR.GE);
   }
 
   @Override
-  public void onMod(final Token<?> lookhead) {
+  public void onMod(final Token<?> lookahead) {
     emit(OperatorIR.MOD);
   }
 
   @Override
-  public void onNot(final Token<?> lookhead) {
+  public void onNot(final Token<?> lookahead) {
     emit(OperatorIR.NOT);
   }
 
   @Override
-  public void onNeg(final Token<?> lookhead) {
+  public void onNeg(final Token<?> lookahead) {
     emit(OperatorIR.NEG);
   }
 
@@ -401,38 +401,38 @@ private void resolveLabels(final List<IR> instruments) {
   }
 
   @Override
-  public void onConstant(final Token<?> lookhead) {
-    if (LOAD_CONSTANTS_TYPE.contains(lookhead.getType())) {
+  public void onConstant(final Token<?> lookahead) {
+    if (LOAD_CONSTANTS_TYPE.contains(lookahead.getType())) {
       VariableMeta meta = null;
 
-      if (lookhead.getType() == TokenType.Variable) {
-        meta = this.variables.get(lookhead.getLexeme());
+      if (lookahead.getType() == TokenType.Variable) {
+        meta = this.variables.get(lookahead.getLexeme());
       }
 
-      emit(new LoadIR(this.sourceFile, lookhead, meta, this.constantPool.contains(lookhead)));
+      emit(new LoadIR(this.sourceFile, lookahead, meta, this.constantPool.contains(lookahead)));
     }
   }
 
   @Override
-  public void onMethodName(final Token<?> lookhead) {
-    final MethodMetaData metadata = new MethodMetaData(lookhead,
-        lookhead.getType() == TokenType.Delegate ? null : lookhead.getLexeme());
+  public void onMethodName(final Token<?> lookahead) {
+    final MethodMetaData metadata = new MethodMetaData(lookahead,
+        lookahead.getType() == TokenType.Delegate ? null : lookahead.getLexeme());
     this.methodMetaDataStack.push(metadata);
   }
 
   @Override
-  public void onMethodParameter(final Token<?> lookhead) {
+  public void onMethodParameter(final Token<?> lookahead) {
     MethodMetaData currentMethodMetaData = this.methodMetaDataStack.peek();
     currentMethodMetaData.parameterCount++;
   }
 
   @Override
-  public void onMethodInvoke(final Token<?> lookhead) {
+  public void onMethodInvoke(final Token<?> lookahead) {
 
     final MethodMetaData methodMetaData = this.methodMetaDataStack.pop();
     @SuppressWarnings("unchecked")
-    final List<FunctionArgument> params = lookhead != null
-        ? (List<FunctionArgument>) lookhead.getMeta(Constants.PARAMS_META, Collections.EMPTY_LIST)
+    final List<FunctionArgument> params = lookahead != null
+        ? (List<FunctionArgument>) lookahead.getMeta(Constants.PARAMS_META, Collections.EMPTY_LIST)
         : Collections.<FunctionArgument>emptyList();
 
     if (this.instance.getOptionValue(Options.CAPTURE_FUNCTION_ARGS).bool) {
@@ -447,10 +447,10 @@ public void onMethodInvoke(final Token<?> lookhead) {
   }
 
   @Override
-  public void onLambdaDefineStart(final Token<?> lookhead) {
+  public void onLambdaDefineStart(final Token<?> lookahead) {
     if (this.lambdaGenerator == null) {
-      Boolean newLexicalScope = lookhead.getMeta(Constants.SCOPE_META, false);
-      Boolean inheritEnv = lookhead.getMeta(Constants.INHERIT_ENV_META, false);
+      Boolean newLexicalScope = lookahead.getMeta(Constants.SCOPE_META, false);
+      Boolean inheritEnv = lookahead.getMeta(Constants.INHERIT_ENV_META, false);
       // TODO cache?
       this.lambdaGenerator = new LambdaGenerator(this.instance, this, this.parser, this.classLoader,
           this.sourceFile, newLexicalScope, inheritEnv);
@@ -462,18 +462,18 @@ public void onLambdaDefineStart(final Token<?> lookhead) {
   }
 
   @Override
-  public void onLambdaArgument(final Token<?> lookhead, final FunctionParam param) {
+  public void onLambdaArgument(final Token<?> lookahead, final FunctionParam param) {
     this.lambdaGenerator.addParam(param);
   }
 
   @Override
-  public void onLambdaBodyStart(final Token<?> lookhead) {
+  public void onLambdaBodyStart(final Token<?> lookahead) {
     this.parentCodeGenerator = this.parser.getCodeGenerator();
     this.parser.setCodeGenerator(this.lambdaGenerator);
   }
 
   @Override
-  public void onLambdaBodyEnd(final Token<?> lookhead) {
+  public void onLambdaBodyEnd(final Token<?> lookahead) {
     // this.lambdaGenerator.compileCallMethod();
     LambdaFunctionBootstrap bootstrap = this.lambdaGenerator.getLmabdaBootstrap();
     if (this.lambdaBootstraps == null) {
@@ -488,15 +488,15 @@ public void onLambdaBodyEnd(final Token<?> lookhead) {
   }
 
   @Override
-  public void onArray(final Token<?> lookhead) {
-    onConstant(lookhead);
+  public void onArray(final Token<?> lookahead) {
+    onConstant(lookahead);
   }
 
   @Override
   public void onArrayIndexStart(final Token<?> token) {}
 
   @Override
-  public void onArrayIndexEnd(final Token<?> lookhead) {
+  public void onArrayIndexEnd(final Token<?> lookahead) {
     emit(OperatorIR.INDEX);
   }
 
diff --git a/src/main/java/com/googlecode/aviator/lexer/token/OperatorToken.java b/src/main/java/com/googlecode/aviator/lexer/token/OperatorToken.java
index ff867399..b9833af7 100644
--- a/src/main/java/com/googlecode/aviator/lexer/token/OperatorToken.java
+++ b/src/main/java/com/googlecode/aviator/lexer/token/OperatorToken.java
@@ -35,10 +35,10 @@ public OperatorType getOperatorType() {
   }
 
 
-  public OperatorToken(final Token<?> lookhead, final OperatorType operatorType) {
-    super(operatorType.getToken(), lookhead != null ? lookhead.getLineNo() : 0,
-        lookhead != null ? lookhead.getStartIndex() : -1);
-    setMetaMap(lookhead != null ? lookhead.getMetaMap() : null);
+  public OperatorToken(final Token<?> lookahead, final OperatorType operatorType) {
+    super(operatorType.getToken(), lookahead != null ? lookahead.getLineNo() : 0,
+        lookahead != null ? lookahead.getStartIndex() : -1);
+    setMetaMap(lookahead != null ? lookahead.getMetaMap() : null);
     this.operatorType = operatorType;
   }
 
diff --git a/src/main/java/com/googlecode/aviator/parser/ExpressionParser.java b/src/main/java/com/googlecode/aviator/parser/ExpressionParser.java
index 98ff2327..8569ffe4 100644
--- a/src/main/java/com/googlecode/aviator/parser/ExpressionParser.java
+++ b/src/main/java/com/googlecode/aviator/parser/ExpressionParser.java
@@ -54,9 +54,9 @@ public class ExpressionParser implements Parser {
   private final ExpressionLexer lexer;
 
   /*
-   * Lookhead token
+   * lookahead token
    */
-  private Token<?> lookhead;
+  private Token<?> lookahead;
 
   private final ArrayDeque<Token<?>> prevTokens = new ArrayDeque<>();
 
@@ -95,8 +95,8 @@ public CodeGenerator getCodeGenerator() {
 
 
 
-  public Token<?> getLookhead() {
-    return this.lookhead;
+  public Token<?> getLookahead() {
+    return this.lookahead;
   }
 
 
@@ -146,12 +146,12 @@ public ExpressionParser(final AviatorEvaluatorInstance instance, final Expressio
     this.instance = instance;
     this.captureFuncArgs = instance.getOptionValue(Options.CAPTURE_FUNCTION_ARGS).bool;
     this.lexer = lexer;
-    this.lookhead = this.lexer.scan();
-    if (this.lookhead != null) {
+    this.lookahead = this.lexer.scan();
+    if (this.lookahead != null) {
       this.parsedTokens++;
     }
     this.featureSet = this.instance.getOptionValue(Options.FEATURE_SET).featureSet;
-    if (this.lookhead == null) {
+    if (this.lookahead == null) {
       reportSyntaxError("blank script");
     }
     setCodeGenerator(codeGenerator);
@@ -170,14 +170,14 @@ private void ensureFeatureEnabled(final Feature feature) {
   public void returnStatement() {
     move(true);
     CodeGenerator cg = getCodeGeneratorWithTimes();
-    cg.onTernaryEnd(this.lookhead);
+    cg.onTernaryEnd(this.lookahead);
     if (expectChar(';')) {
       // 'return;' => 'return nil;'
       if (this.scope.newLexicalScope) {
         cg.onMethodName(Constants.ReducerReturnFn);
         cg.onConstant(Variable.NIL);
-        cg.onMethodParameter(this.lookhead);
-        cg.onMethodInvoke(this.lookhead);
+        cg.onMethodParameter(this.lookahead);
+        cg.onMethodInvoke(this.lookahead);
       } else {
         cg.onConstant(Variable.NIL);
       }
@@ -189,8 +189,8 @@ public void returnStatement() {
         if (!ternary()) {
           reportSyntaxError("invalid value for return, missing ';'?");
         }
-        cg.onMethodParameter(this.lookhead);
-        cg.onMethodInvoke(this.lookhead);
+        cg.onMethodParameter(this.lookahead);
+        cg.onMethodInvoke(this.lookahead);
       } else {
         if (!ternary()) {
           reportSyntaxError("invalid value for return, missing ';'?");
@@ -207,16 +207,16 @@ public void returnStatement() {
   public boolean ternary() {
     int gcTimes = this.getCGTimes;
 
-    if (this.lookhead == Variable.NEW) {
+    if (this.lookahead == Variable.NEW) {
       newStatement();
       return true;
     }
 
     join();
-    if (this.lookhead == null || expectChar(':') || expectChar(',')) {
+    if (this.lookahead == null || expectChar(':') || expectChar(',')) {
       return gcTimes < this.getCGTimes;
     }
-    Token<?> opToken = this.lookhead;
+    Token<?> opToken = this.lookahead;
     if (expectChar('?')) {
       move(true);
       CodeGenerator cg = getCodeGeneratorWithTimes();
@@ -226,11 +226,11 @@ public boolean ternary() {
       }
       if (expectChar(':')) {
         move(true);
-        cg.onTernaryLeft(this.lookhead);
+        cg.onTernaryLeft(this.lookahead);
         if (!ternary()) {
           reportSyntaxError("invalid token for ternary operator");
         }
-        cg.onTernaryRight(this.lookhead);
+        cg.onTernaryRight(this.lookahead);
       } else {
         reportSyntaxError("expect ':'");
       }
@@ -242,7 +242,7 @@ public boolean ternary() {
   public void join() {
     and();
     while (true) {
-      Token<?> opToken = this.lookhead;
+      Token<?> opToken = this.lookahead;
       if (expectChar('|')) {
         getCodeGeneratorWithTimes().onJoinLeft(opToken);
         move(true);
@@ -276,17 +276,17 @@ public void join() {
 
 
   private boolean expectChar(final char ch) {
-    if (this.lookhead == null) {
+    if (this.lookahead == null) {
       return false;
     }
-    return this.lookhead.getType() == TokenType.Char && ((CharToken) this.lookhead).getCh() == ch;
+    return this.lookahead.getType() == TokenType.Char && ((CharToken) this.lookahead).getCh() == ch;
   }
 
 
   public void bitOr() {
     xor();
     while (true) {
-      Token<?> opToken = this.lookhead;
+      Token<?> opToken = this.lookahead;
       if (expectChar('|')) {
         move(true);
         if (expectChar('|')) {
@@ -305,7 +305,7 @@ public void bitOr() {
   public void xor() {
     bitAnd();
     while (true) {
-      Token<?> opToken = this.lookhead;
+      Token<?> opToken = this.lookahead;
       if (expectChar('^')) {
         move(true);
         bitAnd();
@@ -320,7 +320,7 @@ public void xor() {
   public void bitAnd() {
     equality();
     while (true) {
-      Token<?> opToken = this.lookhead;
+      Token<?> opToken = this.lookahead;
       if (expectChar('&')) {
         move(true);
         if (expectChar('&')) {
@@ -339,7 +339,7 @@ public void bitAnd() {
   public void and() {
     bitOr();
     while (true) {
-      Token<?> opToken = this.lookhead;
+      Token<?> opToken = this.lookahead;
 
       if (expectChar('&')) {
         CodeGenerator cg = getCodeGeneratorWithTimes();
@@ -379,7 +379,7 @@ public void and() {
   public void equality() {
     rel();
     while (true) {
-      Token<?> opToken = this.lookhead;
+      Token<?> opToken = this.lookahead;
       Token<?> prevToken = getPrevToken();
       if (expectChar('=')) {
         move(true);
@@ -483,7 +483,7 @@ private void checkVarIsInit(final Token<?> prevToken, StatementType stmtType) {
   public void rel() {
     shift();
     while (true) {
-      Token<?> opToken = this.lookhead;
+      Token<?> opToken = this.lookahead;
       if (expectChar('<')) {
         move(true);
         if (expectChar('=')) {
@@ -514,7 +514,7 @@ public void rel() {
   public void shift() {
     expr();
     while (true) {
-      Token<?> opToken = this.lookhead;
+      Token<?> opToken = this.lookahead;
       if (expectChar('<')) {
         move(true);
         if (expectChar('<')) {
@@ -552,7 +552,7 @@ public void shift() {
   public void expr() {
     term();
     while (true) {
-      Token<?> opToken = this.lookhead;
+      Token<?> opToken = this.lookahead;
       if (expectChar('+')) {
         move(true);
         term();
@@ -570,7 +570,7 @@ public void expr() {
   public void exponent() {
     factor();
     while (true) {
-      Token<?> opToken = this.lookhead;
+      Token<?> opToken = this.lookahead;
       if (expectChar('*')) {
         move(true);
         if (expectChar('*')) {
@@ -591,7 +591,7 @@ public void exponent() {
   public void term() {
     unary();
     while (true) {
-      Token<?> opToken = this.lookhead;
+      Token<?> opToken = this.lookahead;
       if (expectChar('*')) {
         move(true);
         unary();
@@ -612,7 +612,7 @@ public void term() {
 
 
   public void unary() {
-    Token<?> opToken = this.lookhead;
+    Token<?> opToken = this.lookahead;
     if (expectChar('!')) {
       move(true);
       // check if it is a seq function call,"!" as variable
@@ -648,15 +648,16 @@ public void unary() {
     }
   }
 
-  private int getLookheadStartIndex() {
-    // We should calculate the lookhead token's start index, because the token may be reserved by
+  private int getLookaheadStartIndex() {
+    // We should calculate the lookahead token's start index, because the token may be reserved by
     // symbol table and it's start index is wrong.
-    return this.lookhead != null ? (this.lexer.getCurrentIndex() - getLookheadLexemeLength()) : -1;
+    return this.lookahead != null ? (this.lexer.getCurrentIndex() - getLookaheadLexemeLength())
+        : -1;
   }
 
-  private int getLookheadLexemeLength() {
-    int len = this.lookhead.getLexeme().length();
-    if (this.lookhead.getType() == TokenType.String) {
+  private int getLookaheadLexemeLength() {
+    int len = this.lookahead.getLexeme().length();
+    if (this.lookahead.getType() == TokenType.String) {
       // Must include quote symbols.
       len += 2;
     }
@@ -664,8 +665,8 @@ private int getLookheadLexemeLength() {
   }
 
   private String getParamExp(final int lastTokenIndex) {
-    if (lastTokenIndex >= 0 && getLookheadStartIndex() >= 0) {
-      return this.lexer.getScanString().substring(lastTokenIndex, getLookheadStartIndex());
+    if (lastTokenIndex >= 0 && getLookaheadStartIndex() >= 0) {
+      return this.lexer.getScanString().substring(lastTokenIndex, getLookaheadStartIndex());
     } else {
       return null;
     }
@@ -704,10 +705,10 @@ public void factor() {
 
 
   private boolean factor0() {
-    if (this.lookhead == null) {
+    if (this.lookahead == null) {
       reportSyntaxError("illegal token");
     }
-    if (this.lookhead == Variable.END) {
+    if (this.lookahead == Variable.END) {
       return false;
     }
     if (expectChar('(')) {
@@ -718,21 +719,21 @@ private boolean factor0() {
         move(true);
         this.scope.leaveParen();
       }
-    } else if (this.lookhead.getType() == TokenType.Number
-        || this.lookhead.getType() == TokenType.String
-        || this.lookhead.getType() == TokenType.Variable || this.lookhead == Variable.TRUE
-        || this.lookhead == Variable.FALSE || isOPVariable(this.lookhead)) {
-      if (this.lookhead.getType() == TokenType.Variable) {
-        checkVariableName(this.lookhead);
+    } else if (this.lookahead.getType() == TokenType.Number
+        || this.lookahead.getType() == TokenType.String
+        || this.lookahead.getType() == TokenType.Variable || this.lookahead == Variable.TRUE
+        || this.lookahead == Variable.FALSE || isOPVariable(this.lookahead)) {
+      if (this.lookahead.getType() == TokenType.Variable) {
+        checkVariableName(this.lookahead);
       }
       // binary operation as variable for seq functions
-      if (this.lookhead.getType() == TokenType.Char) {
-        CharToken charToken = (CharToken) this.lookhead;
+      if (this.lookahead.getType() == TokenType.Char) {
+        CharToken charToken = (CharToken) this.lookahead;
         if (!ExpressionLexer.isBinaryOP(charToken.getCh())) {
           reportSyntaxError("unexpect char '" + charToken.getCh() + "'");
         }
         // make it as variable
-        this.lookhead = this.lexer.getSymbolTable().reserve(
+        this.lookahead = this.lexer.getSymbolTable().reserve(
             new Variable(charToken.getLexeme(), charToken.getLineNo(), charToken.getStartIndex()));
       }
       move(true);
@@ -817,7 +818,7 @@ private void lambda(final boolean fn) {
       }
 
       move(true);
-      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookahead);
       statements();
 
       if (fn) {
@@ -825,19 +826,19 @@ private void lambda(final boolean fn) {
           reportSyntaxError("missing '}' to close function body");
         }
       } else {
-        if (this.lookhead != Variable.END) {
+        if (this.lookahead != Variable.END) {
           reportSyntaxError("expect lambda 'end'");
         }
       }
 
-      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookahead);
       this.scope.leaveLambda();
       move(true);
     }
   }
 
   private String currentTokenLexeme() {
-    return this.lookhead == null ? "END_OF_STRING" : this.lookhead.getLexeme();
+    return this.lookahead == null ? "END_OF_STRING" : this.lookahead.getLexeme();
   }
 
 
@@ -845,12 +846,12 @@ private FunctionParam lambdaArgument(final int index) {
     if (expectChar('&')) {
       move(true);
 
-      if (this.lookhead.getType() != TokenType.Variable) {
+      if (this.lookahead.getType() != TokenType.Variable) {
         reportSyntaxError("expect argument name, but is: " + currentTokenLexeme());
       }
 
       return lambdaArgument0(index, true);
-    } else if (this.lookhead.getType() == TokenType.Variable) {
+    } else if (this.lookahead.getType() == TokenType.Variable) {
       return lambdaArgument0(index, false);
     } else {
       reportSyntaxError("expect argument name, but is: " + currentTokenLexeme());
@@ -859,11 +860,11 @@ private FunctionParam lambdaArgument(final int index) {
   }
 
   private FunctionParam lambdaArgument0(final int index, final boolean isVariadic) {
-    if (!isJavaIdentifier(this.lookhead.getLexeme())) {
+    if (!isJavaIdentifier(this.lookahead.getLexeme())) {
       reportSyntaxError("illegal argument name: " + currentTokenLexeme());
     }
-    final FunctionParam param = new FunctionParam(index, this.lookhead.getLexeme(), isVariadic);
-    getCodeGeneratorWithTimes().onLambdaArgument(this.lookhead, param);
+    final FunctionParam param = new FunctionParam(index, this.lookahead.getLexeme(), isVariadic);
+    getCodeGeneratorWithTimes().onLambdaArgument(this.lookahead, param);
     move(true);
     return param;
   }
@@ -900,7 +901,7 @@ private void array() {
     if (expectChar(']')) {
       this.scope.leaveBracket();
       move(true);
-      getCodeGeneratorWithTimes().onArrayIndexEnd(this.lookhead);
+      getCodeGeneratorWithTimes().onArrayIndexEnd(this.lookahead);
     }
   }
 
@@ -944,7 +945,7 @@ private void method(final Token<?> methodName) {
       if (this.captureFuncArgs) {
         params = new ArrayList<>();
       }
-      int lastTokenIndex = getLookheadStartIndex();
+      int lastTokenIndex = getLookaheadStartIndex();
       if (!expectChar(')')) {
 
         boolean isPackArgs = false;
@@ -966,14 +967,14 @@ private void method(final Token<?> methodName) {
           withMetaEnd(Constants.UNPACK_ARGS, true);
         }
 
-        getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+        getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
         if (this.captureFuncArgs) {
           params.add(new FunctionArgument(paramIndex++, getParamExp(lastTokenIndex)));
         }
         while (expectChar(',')) {
           move(true);
           isPackArgs = false;
-          lastTokenIndex = getLookheadStartIndex();
+          lastTokenIndex = getLookaheadStartIndex();
           if (expectChar('*')) {
             move(true);
             if (expectChar('*') || expectChar(',')) {
@@ -994,7 +995,7 @@ private void method(final Token<?> methodName) {
             withMetaEnd(Constants.UNPACK_ARGS, true);
           }
 
-          getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+          getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
           if (this.captureFuncArgs) {
             params.add(new FunctionArgument(paramIndex++, getParamExp(lastTokenIndex)));
           }
@@ -1046,13 +1047,13 @@ public static final boolean isJavaIdentifier(final String id) {
 
   private void pattern() {
     // It is a pattern
-    int startIndex = this.lookhead.getStartIndex();
+    int startIndex = this.lookahead.getStartIndex();
     move(true);
     this.inPattern = true;
     StringBuilder sb = new StringBuilder();
-    while (this.lookhead != null) {
-      while (!expectChar('/') && this.lookhead != null) {
-        sb.append(this.lookhead.getLexeme());
+    while (this.lookahead != null) {
+      while (!expectChar('/') && this.lookahead != null) {
+        sb.append(this.lookahead.getLexeme());
         move(false);
       }
       if (getPrevToken().getType() == TokenType.Char
@@ -1074,17 +1075,17 @@ private void pattern() {
 
 
   public void reportSyntaxError(final String message) {
-    int index = isValidLookhead() ? this.lookhead.getStartIndex() : this.lexer.getCurrentIndex();
+    int index = isValidLookahead() ? this.lookahead.getStartIndex() : this.lexer.getCurrentIndex();
 
-    if (this.lookhead != null) {
-      this.lexer.pushback(this.lookhead);
+    if (this.lookahead != null) {
+      this.lexer.pushback(this.lookahead);
     }
 
     String msg = "Syntax error: " + message + //
         " at " + index + //
         ", lineNumber: " + this.lexer.getLineNo() + //
         ", token : " + //
-        this.lookhead + ",\nwhile parsing expression: `\n" + //
+        this.lookahead + ",\nwhile parsing expression: `\n" + //
         this.lexer.getScanString() + "^^^\n`";
 
     ExpressionSyntaxErrorException e = new ExpressionSyntaxErrorException(msg);
@@ -1101,15 +1102,15 @@ public void reportSyntaxError(final String message) {
     throw e;
   }
 
-  private boolean isValidLookhead() {
-    return this.lookhead != null && this.lookhead.getStartIndex() > 0;
+  private boolean isValidLookahead() {
+    return this.lookahead != null && this.lookahead.getStartIndex() > 0;
   }
 
   public void move(final boolean analyse) {
-    if (this.lookhead != null) {
-      this.prevTokens.push(this.lookhead);
-      this.lookhead = this.lexer.scan(analyse);
-      if (this.lookhead != null) {
+    if (this.lookahead != null) {
+      this.prevTokens.push(this.lookahead);
+      this.lookahead = this.lexer.scan(analyse);
+      if (this.lookahead != null) {
         this.parsedTokens++;
       }
     } else {
@@ -1122,17 +1123,17 @@ public int getParsedTokens() {
   }
 
   public void back() {
-    if (this.lookhead != null) {
+    if (this.lookahead != null) {
       this.parsedTokens--;
     }
-    this.lexer.pushback(this.lookhead);
-    this.lookhead = getPrevToken();
+    this.lexer.pushback(this.lookahead);
+    this.lookahead = getPrevToken();
   }
 
 
   public Expression parse(final boolean reportErrorIfNotEOF) {
     StatementType statementType = statements();
-    if (this.lookhead != null && reportErrorIfNotEOF) {
+    if (this.lookahead != null && reportErrorIfNotEOF) {
       if (statementType == StatementType.Ternary) {
         reportSyntaxError("unexpect token '" + currentTokenLexeme()
             + "', maybe forget to insert ';' to complete last expression ");
@@ -1161,7 +1162,7 @@ private void breakStatement() {
     }
     move(true);
     getCodeGeneratorWithTimes().onMethodName(Constants.ReducerBreakFn);
-    getCodeGeneratorWithTimes().onMethodInvoke(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodInvoke(this.lookahead);
     if (!expectChar(';')) {
       reportSyntaxError("missing ';' for break");
     }
@@ -1178,8 +1179,8 @@ private void continueStatement() {
     move(true);
     getCodeGeneratorWithTimes().onMethodName(Constants.ReducerContFn);
     getCodeGeneratorWithTimes().onConstant(Variable.NIL);
-    getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
-    getCodeGeneratorWithTimes().onMethodInvoke(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
+    getCodeGeneratorWithTimes().onMethodInvoke(this.lookahead);
     if (!expectChar(';')) {
       reportSyntaxError("missing ';' for continue");
     }
@@ -1215,7 +1216,7 @@ private void whileStatement() {
     // prepare to call __reducer_callcc(LOOP, iterator, statements)
     getCodeGeneratorWithTimes().onMethodName(Constants.ReducerFn);
     getCodeGeneratorWithTimes().onConstant(Constants.REDUCER_LOOP);
-    getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
 
     // create a lambda function wraps while body(iterator)
     boolean newLexicalScope = this.scope.newLexicalScope;
@@ -1223,10 +1224,10 @@ private void whileStatement() {
     {
       getCodeGeneratorWithTimes().onLambdaDefineStart(
           getPrevToken().withMeta(Constants.SCOPE_META, this.scope.newLexicalScope));
-      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookahead);
       ifStatement(true, false);
-      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookhead);
-      getCodeGenerator().onMethodParameter(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookahead);
+      getCodeGenerator().onMethodParameter(this.lookahead);
     }
 
     if (expectChar(';')) {
@@ -1237,16 +1238,16 @@ private void whileStatement() {
       getCodeGeneratorWithTimes().onLambdaDefineStart(
           getPrevToken().withMeta(Constants.SCOPE_META, this.scope.newLexicalScope) //
               .withMeta(Constants.INHERIT_ENV_META, true));
-      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookahead);
       if (statements() == StatementType.Empty) {
         getCodeGenerator().onConstant(Constants.ReducerEmptyVal);
       }
-      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookahead);
     }
-    getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
 
     // call __reducer_callcc(LOOP, iterator, statements)
-    getCodeGeneratorWithTimes().onMethodInvoke(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodInvoke(this.lookahead);
     // restore newLexicalScope
     this.scope.newLexicalScope = newLexicalScope;
 
@@ -1254,7 +1255,7 @@ private void whileStatement() {
 
   private void letStatement() {
     move(true);
-    Token<?> var = this.lookhead;
+    Token<?> var = this.lookahead;
     checkVariableName(var);
     getCodeGenerator().onConstant(var);
     move(true);
@@ -1283,9 +1284,9 @@ private void fnStatement() {
       lambda(true);
     } else {
 
-      checkVariableName(this.lookhead);
-      checkFunctionName(this.lookhead, true);
-      getCodeGeneratorWithTimes().onConstant(this.lookhead.withMeta(Constants.INIT_META, true)
+      checkVariableName(this.lookahead);
+      checkFunctionName(this.lookahead, true);
+      getCodeGeneratorWithTimes().onConstant(this.lookahead.withMeta(Constants.INIT_META, true)
           .withMeta(Constants.TYPE_META, CompileTypes.Function));
       move(true);
       if (!expectChar('(')) {
@@ -1310,7 +1311,7 @@ private void checkFunctionName(final Token<?> token, final boolean warnOnExists)
   }
 
   private Token<?> currentToken() {
-    Token<?> token = this.lookhead;
+    Token<?> token = this.lookahead;
     if (token == null) {
       token = new CharToken((char) -1, this.lexer.getLineNo(), this.lexer.getCurrentIndex());
     }
@@ -1348,18 +1349,18 @@ private boolean scopeStatement() {
       this.scope.enterBrace();
       getCodeGeneratorWithTimes().onLambdaDefineStart(
           getPrevToken().withMeta(Constants.SCOPE_META, this.scope.newLexicalScope));
-      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookahead);
       hasReturn = statements() == StatementType.Return;
-      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookahead);
       getCodeGeneratorWithTimes().onMethodName(anonymousMethodName());
-      getCodeGeneratorWithTimes().onMethodInvoke(this.lookhead);
+      getCodeGeneratorWithTimes().onMethodInvoke(this.lookahead);
 
       if (!expectChar('}')) {
         reportSyntaxError("missing '}' to close scope");
       }
       move(true);
       this.scope.leaveBrace();
-      getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+      getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
     }
 
     if (expectChar(';')) {
@@ -1370,16 +1371,16 @@ private boolean scopeStatement() {
       getCodeGeneratorWithTimes().onLambdaDefineStart(
           getPrevToken().withMeta(Constants.SCOPE_META, this.scope.newLexicalScope) //
               .withMeta(Constants.INHERIT_ENV_META, true));
-      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookahead);
       if (statements() == StatementType.Empty) {
         getCodeGenerator().onConstant(Constants.ReducerEmptyVal);
       }
-      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookahead);
     }
-    getCodeGenerator().onMethodParameter(this.lookhead);
+    getCodeGenerator().onMethodParameter(this.lookahead);
 
     // call __if_callcc(result, statements)
-    getCodeGenerator().onMethodInvoke(this.lookhead);
+    getCodeGenerator().onMethodInvoke(this.lookahead);
     this.scope.newLexicalScope = newLexicalScope;
 
     return hasReturn;
@@ -1400,10 +1401,10 @@ private void tryStatement() {
 
       getCodeGeneratorWithTimes().onLambdaDefineStart(
           getPrevToken().withMeta(Constants.SCOPE_META, this.scope.newLexicalScope));
-      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookahead);
       statements();
-      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookhead);
-      getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookahead);
+      getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
     }
     if (!expectChar('}')) {
       reportSyntaxError("missing '}' for try body");
@@ -1412,7 +1413,7 @@ private void tryStatement() {
     boolean hasCatch = false;
     boolean hasFinally = false;
 
-    while (this.lookhead == Variable.CATCH) {
+    while (this.lookahead == Variable.CATCH) {
       if (!hasCatch) {
         // create a handler list.
         getCodeGeneratorWithTimes().onMethodName(Constants.SEQ_LIST_VAR);
@@ -1425,12 +1426,12 @@ private void tryStatement() {
         reportSyntaxError("expect '(' after catch");
       }
       move(true);
-      if (this.lookhead == null || this.lookhead.getType() != TokenType.Variable) {
+      if (this.lookahead == null || this.lookahead.getType() != TokenType.Variable) {
         reportSyntaxError("invalid exception class name");
       }
-      checkVariableName(this.lookhead);
+      checkVariableName(this.lookahead);
       List<Token<?>> exceptionClasses = new ArrayList<>();
-      exceptionClasses.add(this.lookhead);
+      exceptionClasses.add(this.lookahead);
       move(true);
 
       Token<?> boundVar = null;
@@ -1442,18 +1443,18 @@ private void tryStatement() {
         // catch multi exception
         while (expectChar('|')) {
           move(true);
-          if (this.lookhead.getType() != TokenType.Variable) {
+          if (this.lookahead.getType() != TokenType.Variable) {
             reportSyntaxError("invalid exception class to catch");
           }
-          checkVariableName(this.lookhead);
-          exceptionClasses.add(this.lookhead);
+          checkVariableName(this.lookahead);
+          exceptionClasses.add(this.lookahead);
           move(true);
         }
-        if (this.lookhead == null || this.lookhead.getType() != TokenType.Variable) {
+        if (this.lookahead == null || this.lookahead.getType() != TokenType.Variable) {
           reportSyntaxError("invalid bound variable name for exception");
         }
-        checkVariableName(this.lookhead);
-        boundVar = this.lookhead;
+        checkVariableName(this.lookahead);
+        boundVar = this.lookahead;
         move(true);
       }
 
@@ -1473,17 +1474,17 @@ private void tryStatement() {
             getPrevToken().withMeta(Constants.SCOPE_META, this.scope.newLexicalScope));
         getCodeGeneratorWithTimes().onLambdaArgument(boundVar,
             new FunctionParam(0, boundVar.getLexeme(), false));
-        getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookhead);
+        getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookahead);
         statements();
-        getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookhead);
-        getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+        getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookahead);
+        getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
         for (Token<?> exceptionClass : exceptionClasses) {
           getCodeGeneratorWithTimes().onConstant(exceptionClass);
-          getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+          getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
         }
-        getCodeGeneratorWithTimes().onMethodInvoke(this.lookhead);
+        getCodeGeneratorWithTimes().onMethodInvoke(this.lookahead);
       }
-      getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+      getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
       if (!expectChar('}')) {
         reportSyntaxError("missing '}' for to complete catch block");
       }
@@ -1492,14 +1493,14 @@ private void tryStatement() {
 
     if (hasCatch) {
       // Invoke seq.list to create handler list
-      getCodeGeneratorWithTimes().onMethodInvoke(this.lookhead);
-      getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+      getCodeGeneratorWithTimes().onMethodInvoke(this.lookahead);
+      getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
     } else {
       getCodeGeneratorWithTimes().onConstant(Variable.NIL);
-      getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+      getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
     }
 
-    if (this.lookhead == Variable.FINALLY) {
+    if (this.lookahead == Variable.FINALLY) {
       hasFinally = true;
       move(true);
       if (!expectChar('{')) {
@@ -1509,9 +1510,9 @@ private void tryStatement() {
       // create a lambda to
       getCodeGeneratorWithTimes().onLambdaDefineStart(
           getPrevToken().withMeta(Constants.SCOPE_META, this.scope.newLexicalScope));
-      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookahead);
       statements();
-      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookahead);
       if (!expectChar('}')) {
         reportSyntaxError("missing '}' for finally block");
       }
@@ -1532,26 +1533,26 @@ private void tryStatement() {
       getCodeGeneratorWithTimes().onLambdaDefineStart(
           getPrevToken().withMeta(Constants.SCOPE_META, this.scope.newLexicalScope) //
               .withMeta(Constants.INHERIT_ENV_META, true));
-      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookahead);
       if (statements() == StatementType.Empty) {
         getCodeGenerator().onConstant(Constants.ReducerEmptyVal);
       }
-      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookhead);
+      getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookahead);
     }
 
-    getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
 
     this.scope.newLexicalScope = newLexicalScope;
-    getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
-    getCodeGeneratorWithTimes().onMethodInvoke(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
+    getCodeGeneratorWithTimes().onMethodInvoke(this.lookahead);
   }
 
   private void throwStatement() {
     getCodeGeneratorWithTimes().onMethodName(Constants.THROW_VAR);
     move(true);
     statement();
-    getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
-    getCodeGeneratorWithTimes().onMethodInvoke(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
+    getCodeGeneratorWithTimes().onMethodInvoke(this.lookahead);
     if (!expectChar(';')) {
       reportSyntaxError("missing ';' for throw statement");
     }
@@ -1562,13 +1563,13 @@ private void newStatement() {
     getCodeGeneratorWithTimes().onMethodName(Constants.NEW_VAR);
     move(true);
 
-    if (this.lookhead == null || this.lookhead.getType() != TokenType.Variable) {
+    if (this.lookahead == null || this.lookahead.getType() != TokenType.Variable) {
       reportSyntaxError("invalid class name");
     }
-    checkVariableName(this.lookhead);
+    checkVariableName(this.lookahead);
     getCodeGeneratorWithTimes()
-        .onConstant(this.lookhead.withMeta(Constants.TYPE_META, CompileTypes.Class));
-    getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+        .onConstant(this.lookahead.withMeta(Constants.TYPE_META, CompileTypes.Class));
+    getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
     move(true);
 
     if (!expectChar('(')) {
@@ -1579,32 +1580,32 @@ private void newStatement() {
     move(true);
     if (!expectChar(')')) {
       ternary();
-      getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+      getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
       while (expectChar(',')) {
         move(true);
         if (!ternary()) {
           reportSyntaxError("invalid argument");
         }
-        getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+        getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
       }
     }
     if (!expectChar(')')) {
       reportSyntaxError("missing ')' for new statement");
     }
-    getCodeGeneratorWithTimes().onMethodInvoke(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodInvoke(this.lookahead);
     move(true);
     this.scope.leaveParen();
   }
 
   private void className() {
-    if (this.lookhead.getType() != TokenType.Variable && !expectChar('*')) {
+    if (this.lookahead.getType() != TokenType.Variable && !expectChar('*')) {
       reportSyntaxError("expect variable name or * to use");
     }
     if (expectChar('*')) {
       wildcard();
     } else {
-      checkVariableName(this.lookhead);
-      getCodeGenerator().onConstant(this.lookhead.withMeta(Constants.USE_CLASS_PKG, true));
+      checkVariableName(this.lookahead);
+      getCodeGenerator().onConstant(this.lookahead.withMeta(Constants.USE_CLASS_PKG, true));
     }
     move(true);
   }
@@ -1613,22 +1614,22 @@ private void useStatement() {
     getCodeGeneratorWithTimes().onMethodName(Constants.USE_VAR);
     move(true);
     className();
-    getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
 
     if (expectChar('*')) {
       // wildcard
       wildcard();
-      getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+      getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
       move(true);
     } else if (expectChar('{')) {
       this.scope.enterBrace();
       move(true);
       className();
-      getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+      getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
       while (expectChar(',')) {
         move(true);
         className();
-        getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+        getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
       }
       if (!expectChar('}')) {
         reportSyntaxError("expect '}' to complete use statement");
@@ -1638,7 +1639,7 @@ private void useStatement() {
       }
     }
 
-    getCodeGeneratorWithTimes().onMethodInvoke(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodInvoke(this.lookahead);
     if (!expectChar(';')) {
       reportSyntaxError("missing ';' for use statement");
     }
@@ -1648,48 +1649,48 @@ private void useStatement() {
 
   private void wildcard() {
     getCodeGenerator()
-        .onConstant(new Variable("*", this.lookhead.getLineNo(), this.lookhead.getStartIndex()));
+        .onConstant(new Variable("*", this.lookahead.getLineNo(), this.lookahead.getStartIndex()));
   }
 
   private StatementType statement() {
-    if (this.lookhead == Variable.IF) {
+    if (this.lookahead == Variable.IF) {
       ensureFeatureEnabled(Feature.If);
       if (ifStatement(false, false)) {
         return StatementType.Return;
       } else {
         return StatementType.Other;
       }
-    } else if (this.lookhead == Variable.FOR) {
+    } else if (this.lookahead == Variable.FOR) {
       ensureFeatureEnabled(Feature.ForLoop);
       forStatement();
       return StatementType.Other;
-    } else if (this.lookhead == Variable.RETURN) {
+    } else if (this.lookahead == Variable.RETURN) {
       ensureFeatureEnabled(Feature.Return);
       returnStatement();
       return StatementType.Return;
-    } else if (this.lookhead == Variable.BREAK) {
+    } else if (this.lookahead == Variable.BREAK) {
       breakStatement();
       return StatementType.Return;
-    } else if (this.lookhead == Variable.CONTINUE) {
+    } else if (this.lookahead == Variable.CONTINUE) {
       continueStatement();
       return StatementType.Return;
-    } else if (this.lookhead == Variable.LET) {
+    } else if (this.lookahead == Variable.LET) {
       ensureFeatureEnabled(Feature.Let);
       letStatement();
       return StatementType.Other;
-    } else if (this.lookhead == Variable.WHILE) {
+    } else if (this.lookahead == Variable.WHILE) {
       ensureFeatureEnabled(Feature.WhileLoop);
       whileStatement();
       return StatementType.Other;
-    } else if (this.lookhead == Variable.FN) {
+    } else if (this.lookahead == Variable.FN) {
       ensureFeatureEnabled(Feature.Fn);
       fnStatement();
       return StatementType.Other;
-    } else if (this.lookhead == Variable.TRY) {
+    } else if (this.lookahead == Variable.TRY) {
       ensureFeatureEnabled(Feature.ExceptionHandle);
       tryStatement();
       return StatementType.Other;
-    } else if (this.lookhead == Variable.THROW) {
+    } else if (this.lookahead == Variable.THROW) {
       ensureFeatureEnabled(Feature.ExceptionHandle);
       throwStatement();
       return StatementType.Other;
@@ -1700,7 +1701,7 @@ private StatementType statement() {
       } else {
         return StatementType.Other;
       }
-    } else if (this.lookhead == Variable.USE) {
+    } else if (this.lookahead == Variable.USE) {
       ensureFeatureEnabled(Feature.Use);
       useStatement();
       return StatementType.Other;
@@ -1718,14 +1719,14 @@ private void withMetaBegin() {
   }
 
   private void withMetaEnd(final Object key, final Object val) {
-    getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
     getCodeGeneratorWithTimes().onConstant(value2token(key));
-    getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
 
     getCodeGeneratorWithTimes().onConstant(value2token(val));
-    getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
 
-    getCodeGeneratorWithTimes().onMethodInvoke(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodInvoke(this.lookahead);
   }
 
 
@@ -1736,10 +1737,9 @@ private Token<?> value2token(final Object val) {
     } else if (val == null) {
       return Variable.NIL;
     } else if (val instanceof String) {
-      return (new StringToken((String) val, this.lexer.getLineNo(), this.lookhead.getStartIndex()));
+      return (new StringToken((String) val, this.lexer.getLineNo(), this.lookahead.getStartIndex()));
     } else if (val instanceof Number) {
-      return (new NumberToken((Number) val, val.toString(), this.lexer.getLineNo(),
-          this.lookhead.getStartIndex()));
+      return (new NumberToken((Number) val, val.toString(), this.lexer.getLineNo(), this.lookahead.getStartIndex()));
     } else if (val instanceof Boolean) {
       return (((boolean) val) ? Variable.TRUE : Variable.FALSE);
     } else {
@@ -1776,8 +1776,8 @@ private void forStatement() {
       if (reducerArgs.size() > 2) {
         reportSyntaxError("Too many variables in for statement: " + reducerArgs.size());
       }
-      reducerArgs.add(this.lookhead);
-      checkVariableName(this.lookhead);
+      reducerArgs.add(this.lookahead);
+      checkVariableName(this.lookahead);
       move(true);
       if (expectChar(',')) {
         move(true);
@@ -1787,7 +1787,7 @@ private void forStatement() {
       }
     }
 
-    if (this.lookhead == Variable.IN) {
+    if (this.lookahead == Variable.IN) {
       move(true);
       // prepare to call __reducer_callcc(seq, iterator, statements)
       {
@@ -1796,7 +1796,7 @@ private void forStatement() {
         if (!ternary()) {
           reportSyntaxError("missing collection");
         }
-        getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+        getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
       }
       if (expectChar('{')) {
         move(true);
@@ -1815,11 +1815,11 @@ private void forStatement() {
             getCodeGeneratorWithTimes().onLambdaArgument(reducerArg,
                 new FunctionParam(0, reducerArg.getLexeme(), false));
           }
-          getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookhead);
+          getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookahead);
           statements();
-          getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookhead);
+          getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookahead);
           withMetaEnd(Constants.ARITIES_META, Long.valueOf(reducerArgs.size()));
-          getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+          getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
         }
 
         if (expectChar('}')) {
@@ -1837,15 +1837,15 @@ private void forStatement() {
           getCodeGeneratorWithTimes().onLambdaDefineStart(
               getPrevToken().withMeta(Constants.SCOPE_META, this.scope.newLexicalScope) //
                   .withMeta(Constants.INHERIT_ENV_META, true));
-          getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookhead);
+          getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookahead);
           if (statements() == StatementType.Empty) {
             getCodeGenerator().onConstant(Constants.ReducerEmptyVal);
           }
-          getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookhead);
+          getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookahead);
         }
-        getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+        getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
         // call __reducer_callcc(seq, iterator, statements)
-        getCodeGeneratorWithTimes().onMethodInvoke(this.lookhead);
+        getCodeGeneratorWithTimes().onMethodInvoke(this.lookahead);
         // restore newLexicalScope
         this.scope.newLexicalScope = newLexicalScope;
       } else {
@@ -1858,7 +1858,7 @@ private void forStatement() {
 
 
   private StatementType statements() {
-    if (this.lookhead == null) {
+    if (this.lookahead == null) {
       return StatementType.Empty;
     }
 
@@ -1868,15 +1868,15 @@ private StatementType statements() {
 
       ensureNoStatementAfterReturn(stmtType);
 
-      if (this.lookhead != null && this.lookhead != Variable.END && !expectChar('}')) {
-        getCodeGeneratorWithTimes().onTernaryEnd(this.lookhead);
+      if (this.lookahead != null && this.lookahead != Variable.END && !expectChar('}')) {
+        getCodeGeneratorWithTimes().onTernaryEnd(this.lookahead);
       }
 
       if (expectChar(';')) {
         move(true);
       }
 
-      if (this.lookhead == null) {
+      if (this.lookahead == null) {
         break;
       }
 
@@ -1892,7 +1892,7 @@ private StatementType statements() {
     // 'end' keyword, or ';'
     // Otherwise report syntax error.
     if (stmtType == StatementType.Ternary) {
-      if (lookhead != null && !expectChar(';') && !expectChar('}') && lookhead != Variable.END) {
+      if (lookahead != null && !expectChar(';') && !expectChar('}') && lookahead != Variable.END) {
         this.back();
         reportSyntaxError("unexpect token '" + currentTokenLexeme()
             + "', maybe forget to insert ';' to complete last expression ");
@@ -1903,8 +1903,8 @@ private StatementType statements() {
   }
 
   private void ensureNoStatementAfterReturn(final StatementType statementType) {
-    if (statementType == StatementType.Return && this.lookhead != null) {
-      if (this.lookhead != Variable.END && !expectChar('}')) {
+    if (statementType == StatementType.Return && this.lookahead != null) {
+      if (this.lookahead != Variable.END && !expectChar('}')) {
         reportSyntaxError("unreachable code");
       }
     }
@@ -1945,18 +1945,18 @@ private boolean ifStatement(final boolean isWhile, final boolean isElsif) {
         reportSyntaxError("missing test statement for if");
       }
 
-      getCodeGeneratorWithTimes().onTernaryBoolean(this.lookhead);
+      getCodeGeneratorWithTimes().onTernaryBoolean(this.lookahead);
       if (expectChar('{')) {
         move(true);
         this.scope.enterBrace();
         getCodeGeneratorWithTimes().onLambdaDefineStart(
             getPrevToken().withMeta(Constants.SCOPE_META, this.scope.newLexicalScope));
-        getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookhead);
+        getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookahead);
         ifBodyHasReturn = statements() == StatementType.Return;
-        getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookhead);
+        getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookahead);
         getCodeGeneratorWithTimes().onMethodName(anonymousMethodName());
-        getCodeGeneratorWithTimes().onMethodInvoke(this.lookhead);
-        getCodeGeneratorWithTimes().onTernaryLeft(this.lookhead);
+        getCodeGeneratorWithTimes().onMethodInvoke(this.lookahead);
+        getCodeGeneratorWithTimes().onTernaryLeft(this.lookahead);
       } else {
         reportSyntaxError("expect '{' for " + getLoopKeyword(isWhile) + " statement");
       }
@@ -1967,7 +1967,7 @@ private boolean ifStatement(final boolean isWhile, final boolean isElsif) {
       move(true);
 
       elseBodyHasReturn = elseStatement(isWhile, isElsif, ifBodyHasReturn);
-      getCodeGeneratorWithTimes().onMethodParameter(this.lookhead);
+      getCodeGeneratorWithTimes().onMethodParameter(this.lookahead);
     }
 
     {
@@ -1985,7 +1985,7 @@ private boolean ifStatement(final boolean isWhile, final boolean isElsif) {
           getCodeGeneratorWithTimes().onLambdaDefineStart(
               getPrevToken().withMeta(Constants.SCOPE_META, this.scope.newLexicalScope) //
                   .withMeta(Constants.INHERIT_ENV_META, true));
-          getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookhead);
+          getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookahead);
           if (statements() == StatementType.Empty) {
             getCodeGenerator().onConstant(Constants.ReducerEmptyVal);
           } else {
@@ -1993,12 +1993,12 @@ private boolean ifStatement(final boolean isWhile, final boolean isElsif) {
               reportSyntaxError("unreachable code");
             }
           }
-          getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookhead);
+          getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookahead);
         }
       }
-      getCodeGenerator().onMethodParameter(this.lookhead);
+      getCodeGenerator().onMethodParameter(this.lookahead);
       // call __if_callcc(result, statements)
-      getCodeGenerator().onMethodInvoke(this.lookhead);
+      getCodeGenerator().onMethodInvoke(this.lookahead);
       this.scope.newLexicalScope = newLexicalScope;
     }
 
@@ -2016,9 +2016,9 @@ private boolean elseStatement(final boolean isWhile, boolean isElsif,
       final CodeGenerator cg = getCodeGeneratorWithTimes();
       cg.onMethodName(Constants.ReducerBreakFn);
       cg.onConstant(Variable.NIL);
-      cg.onMethodParameter(this.lookhead);
-      cg.onMethodInvoke(this.lookhead);
-      cg.onTernaryRight(this.lookhead);
+      cg.onMethodParameter(this.lookahead);
+      cg.onMethodInvoke(this.lookahead);
+      cg.onTernaryRight(this.lookahead);
       return false;
     }
 
@@ -2027,9 +2027,9 @@ private boolean elseStatement(final boolean isWhile, boolean isElsif,
     }
 
     boolean hasReturn = false;
-    boolean hasElsif = this.lookhead == Variable.ELSIF;
-    boolean hasElse = this.lookhead == Variable.ELSE;
-    if (this.lookhead != null && (hasElse || hasElsif || ifBodyHasReturn)) {
+    boolean hasElsif = this.lookahead == Variable.ELSIF;
+    boolean hasElse = this.lookahead == Variable.ELSE;
+    if (this.lookahead != null && (hasElse || hasElsif || ifBodyHasReturn)) {
       if (hasElse) {
         move(true);
         if (expectChar('{')) {
@@ -2047,7 +2047,7 @@ private boolean elseStatement(final boolean isWhile, boolean isElsif,
         }
       } else if (hasElsif) {
         hasReturn = ifStatement(false, true);
-        getCodeGenerator().onTernaryRight(this.lookhead);
+        getCodeGenerator().onTernaryRight(this.lookahead);
       } else if (ifBodyHasReturn && !isElsif) {
         hasReturn = elseBody(true);
       } else {
@@ -2064,26 +2064,26 @@ private boolean elseStatement(final boolean isWhile, boolean isElsif,
   private boolean withoutElse() {
     final CodeGenerator cg = getCodeGeneratorWithTimes();
     cg.onConstant(Variable.NIL);
-    cg.onTernaryRight(this.lookhead);
+    cg.onTernaryRight(this.lookahead);
     return false;
   }
 
   private boolean elseBody(final boolean inheritEnv) {
-    getCodeGeneratorWithTimes().onLambdaDefineStart(this.lookhead //
+    getCodeGeneratorWithTimes().onLambdaDefineStart(this.lookahead //
         .withMeta(Constants.SCOPE_META, this.scope.newLexicalScope) //
         .withMeta(Constants.INHERIT_ENV_META, inheritEnv) //
     );
-    getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookhead);
+    getCodeGeneratorWithTimes().onLambdaBodyStart(this.lookahead);
     boolean hasReturn = statements() == StatementType.Return;
-    getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookhead);
+    getCodeGeneratorWithTimes().onLambdaBodyEnd(this.lookahead);
     getCodeGeneratorWithTimes().onMethodName(anonymousMethodName());
-    getCodeGeneratorWithTimes().onMethodInvoke(this.lookhead);
-    getCodeGeneratorWithTimes().onTernaryRight(this.lookhead);
+    getCodeGeneratorWithTimes().onMethodInvoke(this.lookahead);
+    getCodeGeneratorWithTimes().onTernaryRight(this.lookahead);
     return hasReturn;
   }
 
   private DelegateToken anonymousMethodName() {
-    return new DelegateToken(this.lookhead, DelegateTokenType.Method_Name);
+    return new DelegateToken(this.lookahead, DelegateTokenType.Method_Name);
   }
 
 
diff --git a/src/test/java/com/googlecode/aviator/parser/FakeCodeGenerator.java b/src/test/java/com/googlecode/aviator/parser/FakeCodeGenerator.java
index 226473ab..39bd06c4 100644
--- a/src/test/java/com/googlecode/aviator/parser/FakeCodeGenerator.java
+++ b/src/test/java/com/googlecode/aviator/parser/FakeCodeGenerator.java
@@ -64,13 +64,13 @@ public String getPostFixExpression() {
 
 
   @Override
-  public void onAdd(final Token<?> lookhead) {
+  public void onAdd(final Token<?> lookahead) {
     appendToken("+");
   }
 
 
   @Override
-  public void onTernaryEnd(final Token<?> lookhead) {
+  public void onTernaryEnd(final Token<?> lookahead) {
     appendToken(";");
 
   }
@@ -85,179 +85,179 @@ private void appendToken(final String s) {
   }
 
   @Override
-  public void onAndLeft(final Token<?> lookhead) {
+  public void onAndLeft(final Token<?> lookahead) {
 
   }
 
 
   @Override
-  public void onAndRight(final Token<?> lookhead) {
+  public void onAndRight(final Token<?> alookahead) {
     appendToken("&&");
 
   }
 
 
   @Override
-  public void onJoinRight(final Token<?> lookhead) {
+  public void onJoinRight(final Token<?> lookahead) {
     appendToken("||");
   }
 
 
   @Override
-  public void onTernaryBoolean(final Token<?> lookhead) {
+  public void onTernaryBoolean(final Token<?> lookahead) {
 
   }
 
 
   @Override
-  public void onTernaryLeft(final Token<?> lookhead) {
+  public void onTernaryLeft(final Token<?> lookahead) {
 
   }
 
 
   @Override
-  public void onTernaryRight(final Token<?> lookhead) {
+  public void onTernaryRight(final Token<?> lookahead) {
     appendToken("?:");
   }
 
 
   @Override
-  public void onConstant(final Token<?> lookhead) {
-    appendToken(lookhead.getLexeme());
+  public void onConstant(final Token<?> lookahead) {
+    appendToken(lookahead.getLexeme());
   }
 
 
   @Override
-  public void onDiv(final Token<?> lookhead) {
+  public void onDiv(final Token<?> lookahead) {
     appendToken("/");
 
   }
 
 
   @Override
-  public void onEq(final Token<?> lookhead) {
+  public void onEq(final Token<?> lookahead) {
     appendToken("==");
 
   }
 
 
   @Override
-  public void onAssignment(final Token<?> lookhead) {
+  public void onAssignment(final Token<?> lookahead) {
     appendToken("=");
   }
 
 
   @Override
-  public void onGe(final Token<?> lookhead) {
+  public void onGe(final Token<?> lookahead) {
     appendToken(">=");
 
   }
 
 
   @Override
-  public void onGt(final Token<?> lookhead) {
+  public void onGt(final Token<?> lookahead) {
     appendToken(">");
 
   }
 
 
   @Override
-  public void onJoinLeft(final Token<?> lookhead) {
+  public void onJoinLeft(final Token<?> lookahead) {
 
   }
 
 
   @Override
-  public void onLe(final Token<?> lookhead) {
+  public void onLe(final Token<?> lookahead) {
     appendToken("<=");
 
   }
 
 
   @Override
-  public void onLt(final Token<?> lookhead) {
+  public void onLt(final Token<?> lookahead) {
     appendToken("<");
 
   }
 
 
   @Override
-  public void onMatch(final Token<?> lookhead) {
+  public void onMatch(final Token<?> lookahead) {
     appendToken("=~");
 
   }
 
 
   @Override
-  public void onMod(final Token<?> lookhead) {
+  public void onMod(final Token<?> lookahead) {
     appendToken("%");
 
   }
 
 
   @Override
-  public void onMult(final Token<?> lookhead) {
+  public void onMult(final Token<?> lookahead) {
     appendToken("*");
 
   }
 
 
   @Override
-  public void onExponent(final Token<?> lookhead) {
+  public void onExponent(final Token<?> lookahead) {
     appendToken("**");
   }
 
 
   @Override
-  public void onNeg(final Token<?> lookhead) {
+  public void onNeg(final Token<?> lookahead) {
     appendToken("-");
 
   }
 
 
   @Override
-  public void onNeq(final Token<?> lookhead) {
+  public void onNeq(final Token<?> lookahead) {
     appendToken("!=");
 
   }
 
 
   @Override
-  public void onNot(final Token<?> lookhead) {
+  public void onNot(final Token<?> lookahead) {
     appendToken("!");
 
   }
 
 
   @Override
-  public void onSub(final Token<?> lookhead) {
+  public void onSub(final Token<?> lookahead) {
     appendToken("-");
   }
 
 
   @Override
-  public void onMethodInvoke(final Token<?> lookhead) {
-    final List<FunctionArgument> params = lookhead.getMeta(Constants.PARAMS_META, null);
+  public void onMethodInvoke(final Token<?> lookahead) {
+    final List<FunctionArgument> params = lookahead.getMeta(Constants.PARAMS_META, null);
     appendToken("method_invoke<" + (params == null ? "" : params.toString()) + ">");
 
   }
 
 
   @Override
-  public void onMethodName(final Token<?> lookhead) {
+  public void onMethodName(final Token<?> lookahead) {
 
   }
 
 
   @Override
-  public void onMethodParameter(final Token<?> lookhead) {
+  public void onMethodParameter(final Token<?> lookahead) {
 
   }
 
 
   @Override
-  public void onArray(final Token<?> lookhead) {
-    appendToken(lookhead.getLexeme());
+  public void onArray(final Token<?> lookahead) {
+    appendToken(lookahead.getLexeme());
   }
 
 
@@ -268,78 +268,78 @@ public void onArrayIndexStart(final Token<?> token) {
 
 
   @Override
-  public void onArrayIndexEnd(final Token<?> lookhead) {
+  public void onArrayIndexEnd(final Token<?> lookahead) {
     appendToken("[]");
 
   }
 
 
   @Override
-  public void onBitAnd(final Token<?> lookhead) {
+  public void onBitAnd(final Token<?> lookahead) {
     appendToken("&");
 
   }
 
 
   @Override
-  public void onBitNot(final Token<?> lookhead) {
+  public void onBitNot(final Token<?> lookahead) {
     appendToken("~");
 
   }
 
 
   @Override
-  public void onBitOr(final Token<?> lookhead) {
+  public void onBitOr(final Token<?> lookahead) {
     appendToken("|");
 
   }
 
 
   @Override
-  public void onBitXor(final Token<?> lookhead) {
+  public void onBitXor(final Token<?> lookahead) {
     appendToken("^");
 
   }
 
 
   @Override
-  public void onShiftLeft(final Token<?> lookhead) {
+  public void onShiftLeft(final Token<?> lookahead) {
     appendToken("<<");
 
   }
 
   @Override
-  public void onLambdaDefineStart(final Token<?> lookhead) {
-    this.scopes.push(this.parser.enterScope(lookhead.getMeta(Constants.SCOPE_META, false)));
+  public void onLambdaDefineStart(final Token<?> lookahead) {
+    this.scopes.push(this.parser.enterScope(lookahead.getMeta(Constants.SCOPE_META, false)));
   }
 
 
   @Override
-  public void onLambdaBodyStart(final Token<?> lookhead) {
+  public void onLambdaBodyStart(final Token<?> lookahead) {
 
   }
 
 
   @Override
-  public void onLambdaArgument(final Token<?> lookhead, final FunctionParam param) {}
+  public void onLambdaArgument(final Token<?> lookahead, final FunctionParam param) {}
 
 
   @Override
-  public void onLambdaBodyEnd(final Token<?> lookhead) {
+  public void onLambdaBodyEnd(final Token<?> lookahead) {
     appendToken("lambda<defined>");
     this.parser.restoreScope(this.scopes.pop());
   }
 
 
   @Override
-  public void onShiftRight(final Token<?> lookhead) {
+  public void onShiftRight(final Token<?> lookahead) {
     appendToken(">>");
 
   }
 
 
   @Override
-  public void onUnsignedShiftRight(final Token<?> lookhead) {
+  public void onUnsignedShiftRight(final Token<?> lookahead) {
     appendToken(">>>");
 
   }