anchor.diff:  
   let ParseMethodReference scope reference : Mono.Cecil.MethodReference = 
       let (ty, name, genargs, args) = Parser.run Parser.pmethod reference
  -
  -    let ty = ResolveType scope ty
  -    let def = ty.Resolve()
  -
  -    let genargs = genargs |> Option.bind(Seq.map (ResolveType scope) >> Some)
  -    let methods = def.Methods |> Seq.filter (fun m -> m.Name = name)
  -
  -    let meth = 
  -        methods
  -        |> Seq.filter(fun m ->
  -            let args = args |> Seq.map (ResolveType (MethodScope m))
  -            let parameters = m.Parameters |> Seq.map(fun p -> p.ParameterType)
  -            (Seq.compareWith(fun (arg : Mono.Cecil.TypeReference) (param : Mono.Cecil.TypeReference) -> if arg.FullName = param.FullName then 0 else 1) args parameters) = 0)
  -        |> Seq.toList
  -
  -    let meth = 
  -        match meth with  
  -        | [m] -> m
  -        | _ -> failwithf "Could not find unique method %s" reference
  +    let tyRef = ResolveType scope ty
  +
  +    let resolve (def : Mono.Cecil.TypeDefinition) =
  +        let genargs = genargs |> Option.bind(Seq.map (ResolveType scope) >> Some)
  +        let methods = def.Methods |> Seq.filter (fun m -> m.Name = name)
  +
  +        let meth = 
  +            methods
  +            |> Seq.filter(fun m ->
  +                let args = args |> Seq.map (ResolveType (MethodScope m))
  +                let parameters = m.Parameters |> Seq.map(fun p -> p.ParameterType)
  +                (Seq.compareWith(fun (arg : Mono.Cecil.TypeReference) (param : Mono.Cecil.TypeReference) -> if arg.FullName = param.FullName then 0 else 1) args parameters) = 0)
  +            |> Seq.toList
  +
  +        let meth = 
  +            match meth with  
  +            | [m] -> m
  +            | _ -> failwithf "Could not find method %s" reference
       
  -    let currentModule = GetModule scope
  -    let meth =
  -        if meth.Module = currentModule then
  +        let currentModule = GetModule scope
  +        let meth =
  +            if meth.Module = currentModule then
  +                meth :> Mono.Cecil.MethodReference
  +            else
  +                currentModule.Import(meth)
  +
  +        meth.DeclaringType <- tyRef        
  +
  +        match genargs with 
  +        | None -> meth
  +        | Some genargs ->
  +            let meth = Mono.Cecil.GenericInstanceMethod(meth)
  +            genargs |> Seq.iter(fun arg -> meth.GenericArguments.Add(arg))
               meth :> Mono.Cecil.MethodReference
  -        else
  -            currentModule.Import(meth)
  -
  -    meth.DeclaringType <- ty        
  -
  -    match genargs with 
  -    | None -> meth
  -    | Some genargs ->
  -        let meth = Mono.Cecil.GenericInstanceMethod(meth)
  -        genargs |> Seq.iter(fun arg -> meth.GenericArguments.Add(arg))
  -        meth :> Mono.Cecil.MethodReference
  -
  +            
  +
  +    match ty with
  +    | Parser.Array (ty, bounds) ->
  +        // arrays have some special runtime only methods which cecil doesn't pick up
  +        // if the reference matches one of those methods we just return a reference to it
  +        // otherwise we return the base class System.Array so it can be searched
  +        // {Void Set(Int32, Int32)}
  +        // {Int32& Address(Int32)}
  +        // {Int32 Get(Int32)}
  +        let currentModule = GetModule scope
  +        let lengthBounds = Seq.length bounds
  +        let argsToMatch = Seq.init lengthBounds (fun i -> Parser.Class "System.Int32")
  +
  +        let meth = 
  +            match (name, genargs) with
  +            | ("Set", None) ->
  +                let argsToMatch = Seq.concat [argsToMatch; Seq.singleton (Parser.Class "System.Int32")]
  +                if (Seq.compareWith (fun a b -> if a = b then 0 else 1) args argsToMatch) = 0 then
  +                        let meth = Mono.Cecil.MethodReference("Set", currentModule.TypeSystem.Void, tyRef)
  +                        Seq.iter (fun arg -> meth.Parameters.Add(Mono.Cecil.ParameterDefinition(ResolveType scope arg))) argsToMatch
  +                        Some meth
  +                else   
  +                    None
  +            | ("Get", None) ->
  +                if (Seq.compareWith (fun a b -> if a = b then 0 else 1) args argsToMatch) = 0 then
  +                        let meth = Mono.Cecil.MethodReference("Get", ResolveType scope ty, tyRef)
  +                        Seq.iter (fun arg -> meth.Parameters.Add(Mono.Cecil.ParameterDefinition(ResolveType scope arg))) argsToMatch
  +                        Some meth
  +                else   
  +                    None
  +            | ("Address", None) -> 
  +                if (Seq.compareWith (fun a b -> if a = b then 0 else 1) args argsToMatch) = 0 then
  +                        let meth = Mono.Cecil.MethodReference("Address", Mono.Cecil.ByReferenceType(ResolveType scope ty), tyRef)
  +                        Seq.iter (fun arg -> meth.Parameters.Add(Mono.Cecil.ParameterDefinition(ResolveType scope arg))) argsToMatch
  +                        Some meth
  +                else   
  +                    None
  +            | _ -> None
  +            
  +        match meth with
  +        | Some meth -> meth
  +        | None -> resolve ((ParseTypeReference scope "System.Array").Resolve())
  +
  +    | _ -> resolve (tyRef.Resolve())
   
   let ParsePropertyReference scope reference = 
       let (ty, name, args) = Parser.run Parser.pproperty reference
  
positive.code:     let property = 
          match property with  
          | [p] -> p :> Mono.Cecil.PropertyReference
          | _ -> failwithf "Could not find unique property %s" reference
      
      property.DeclaringType <- ty
      property
negative.code:     let field = 
          match fields with  
          | [f] -> f
          | _ -> failwithf "Could not find field %s" reference
          
      let currentModule = GetModule scope
      let field =
  