anchor.diff:  
       (ES3Parser.FUNCTION, fun t s p -> 
         if t.ChildCount = 2 then
  -        let paramNames = "~closure" :: "this" :: [for c in (child t 0).Children -> (ct c).Text ]
  +        let paramNames = "~closure" :: "this" :: [for c in (child t 0).Children -> (ct c).Text]
           let body, scopes = p (child t 1) (addLocals (emptyScope :: s) paramNames)
           Function(paramNames, scopes.Head, Null, body), scopes.Tail
         else
  -        failwith "Not supporting named functions"
  +        failwith "No support for named functions"
       );
   |]
   
  
positive.code: let makeGenerator (handlers:HandlerMap) =
    let rec p (x:CommonTree) (s:Scopes) = 
      if not (handlers.ContainsKey(x.Type)) then
        failwithf "No handler for %A (%A)" ES3Parser.tokenNames.[x.Type] x.Type
      handlers.[x.Type] x s p
    p
  
  let makeBlock ts s p =
    let scopes = ref s
    Block([for c in ts -> getAst scopes (p (ct c) !scopes)]), !scopes
  
  let cleanString (s:string) =
    if s.[0] = '"' then s.Trim('"') else s.Trim('\'')
  
  let exprType expr =
    match expr with
    | Number(Integer(_)) -> Type.Integer
    | Number(Double(_)) -> Type.Double
    | String(_) -> Type.String
    | _ -> Type.Dynamic
  
  let addMetaData (s:Scopes) a b =
    match s with
    | [] -> failwith "Empty scope"
    | x::[] -> s
    | x::xs ->
      match a with
  
negative.code: open IronJS.CSharp.Parser
  open Antlr.Runtime
  open Antlr.Runtime.Tree
  
  //Errors
  let private EmptyScopeChain = "Empty scope-chain"
  let private NoHandlerForType = new Printf.StringFormat<string -> int -> unit>("No handler for %s (%i)")
  
  //Types
  type Type = 
  