anchor.diff:      let property = 
           match property with  
           | [p] -> p :> Mono.Cecil.PropertyReference
  -        | _ -> failwithf "Could not find unique property %s" reference
  +        | _ -> failwithf "Could not find property %s" reference
       
       property.DeclaringType <- ty
       property
positive.code:     let field = 
          match fields with  
          | [f] -> f
          | _ -> failwithf "Could not find unique field %s" reference
          
      let currentModule = GetModule scope
      let field =
  
negative.code: 
  let ParseMethodReference scope reference : Mono.Cecil.MethodReference = 
      let (ty, name, genargs, args) = Parser.run Parser.pmethod 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
                  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
              
  
      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
  