anchor.diff:      let internal hasAttrib<'T> (attribs: IList<FSharpAttribute>) = 
           attribs |> Seq.exists (fun a -> isAttrib<'T>(a))
   
  -    let internal (|MeasureProd|_|) (typ: FSharpType) = 
  -        if typ.HasTypeDefinition && typ.TypeDefinition.LogicalName = "*" && typ.GenericArguments.Count = 2 then
  -            Some (typ.GenericArguments.[0], typ.GenericArguments.[1])
  -        else None
  -
  -    let internal (|MeasureInv|_|) (typ: FSharpType) = 
  -        if typ.HasTypeDefinition && typ.TypeDefinition.LogicalName = "/" && typ.GenericArguments.Count = 1 then 
  -            Some typ.GenericArguments.[0]
  -        else None
  -
  -    let internal (|MeasureOne|_|) (typ: FSharpType) = 
  -        if typ.HasTypeDefinition && typ.TypeDefinition.LogicalName = "1" && typ.GenericArguments.Count = 0 then 
  -            Some ()
  -        else None
  -
       let internal getTypeParameterName (typar: FSharpGenericParameter) =
           (if typar.IsSolveAtCompileTime then "^" else "'") + typar.Name
   
  -    let internal formatTypeArgument (ctx: Context) (typar: FSharpGenericParameter) =
  -        let genericName = getTypeParameterName typar
  -        match ctx.TypeInstantations.TryFind(genericName) with
  -        | Some specificName ->
  -            specificName
  -        | None ->
  -            genericName
  -
  -    let internal formatTypeArguments ctx (typars:seq<FSharpGenericParameter>) =
  -        Seq.map (formatTypeArgument ctx) typars |> List.ofSeq
  -
       let internal bracket (str: string) = 
           if str.Contains(" ") then "(" + str + ")" else str
   
       let internal formatType ctx (typ: FSharpType) =
  -        let genericDefinition = typ.Format(ctx.DisplayContext)
  +        let genericDefinition = typ.Instantiate(Seq.toList ctx.ArgInstantiations).Format(ctx.DisplayContext)
           (genericDefinition, ctx.TypeInstantations)
           ||> Map.fold (fun s k v -> s.Replace(k, v))
   
  
positive.code: 
      /// Generate stub implementation of an interface at a start column
      let formatInterface startColumn indentation (typeInstances: string []) objectIdent 
          (methodBody: string) (displayContext: FSharpDisplayContext) (e: FSharpEntity) =
          Debug.Assert(isInterface e, "The entity should be an interface.")
          use writer = new ColumnIndentedTextWriter()
          let lines = methodBody.Replace("\r\n", "\n").Split('\n')
  
negative.code:         match x with
          | InterfaceData.Interface(typ, _)
          | InterfaceData.ObjExpr(typ, _) ->
              let rec (|TypeIdent|_|) = function
                  | SynType.Var(SynTypar.Typar(s, req , _), _) ->
                      match req with
                      | NoStaticReq -> 
                          Some ("'" + s.idText)
                      | HeadTypeStaticReq -> 
                          Some ("^" + s.idText)
                  | SynType.LongIdent(LongIdentWithDots(xs, _)) ->
                      xs |> Seq.map (fun x -> x.idText) |> String.concat "." |> Some
                  | SynType.App(t, _, ts, _, _, isPostfix, _) ->
                      match t, ts with
                      | TypeIdent typeName, [] -> Some typeName
                      | TypeIdent typeName, [TypeIdent typeArg] -> 
                          if isPostfix then 
                              Some (sprintf "%s %s" typeArg typeName)
                          else
                              Some (sprintf "%s<%s>" typeName typeArg)
                      | TypeIdent typeName, _ -> 
                          let typeArgs = ts |> Seq.choose (|TypeIdent|_|) |> String.concat ", "
                          if isPostfix then 
                              Some (sprintf "(%s) %s" typeArgs typeName)
                          else
                              Some(sprintf "%s<%s>" typeName typeArgs)
                      | _ ->
                          debug "Unsupported case with %A and %A" t ts
                          None
                  | SynType.Anon _ -> 
                      Some "_"
                  | SynType.Tuple(ts, _) ->
                      Some (ts |> Seq.choose (snd >> (|TypeIdent|_|)) |> String.concat " * ")
                  | SynType.Array(dimension, TypeIdent typeName, _) ->
                      Some (sprintf "%s [%s]" typeName (new String(',', dimension-1)))
                  | SynType.MeasurePower(TypeIdent typeName, power, _) ->
                      Some (sprintf "%s^%i" typeName power)
                  | SynType.MeasureDivide(TypeIdent numerator, TypeIdent denominator, _) ->
                      Some (sprintf "%s/%s" numerator denominator)
                  | _ -> 
                      None
              match typ with
              | SynType.App(_, _, ts, _, _, _, _)
              | SynType.LongIdentApp(_, _, _, ts, _, _, _) ->
                  ts |> Seq.choose (|TypeIdent|_|) |> Seq.toArray
              | _ ->
                  [||]
  