anchor.diff:          let generic = Choice3Of3 () : EncodeResult
   
           /// Returns None if MacroNeedsResolvedTypeArg.
  -        let getEncoding name isEnc warn (comp: M.ICompilation) (t: Type) : option<Expression> =
  +        let getEncoding name isEnc param (t: Type) : option<Expression> =
  +            let warn msg = param.Warnings.Add msg
  +            let addTypeDep td = param.Dependencies.Add (M.TypeNode td)
  +            let comp = param.Compilation
               let call = invoke comp isEnc
               let ident = invokeId comp 
               let rec encode t =
  
positive.code: 
      type Parameters =
          {
              Warn : string -> unit
              Provider : Expression
          }
  
      [<AutoOpen>]
  
negative.code:                 | "Serialize" -> Serialize
                  | "Deserialize" -> Deserialize
                  | _ -> failwith "Invalid macro invocation"
              let param = 
                  {
                      Compilation = c.Compilation
                      Warnings = ResizeArray()
                      Dependencies = ResizeArray()
                  }
              let res =
                  match f param c.Method.Generics.Head (last c.Arguments) with
                  | Some x ->
                      WebSharper.Core.MacroOk x
                  | None -> WebSharper.Core.MacroNeedsResolvedTypeArg
              let resWithWarnings =
                  if param.Warnings.Count > 0 then
                      param.Warnings |> Seq.fold (fun res msg -> 
                          WebSharper.Core.MacroWarning (msg, res)) res
                  else res
              if param.Dependencies.Count > 0 then
                  WebSharper.Core.MacroDependencies (List.ofSeq param.Dependencies, resWithWarnings)
              else resWithWarnings    
  open Macro
  
  /// Encodes an object in such a way that JSON stringification
  