anchor.diff:  
   let inline addBodyStatement statement (input:^T) =
       (^T : (member AddBodyStatements : StatementSyntax array -> ^T) (input, [|statement|]))
  -    
  +   
   let inline addMember member' (input:^T) =
       (^T : (member AddMembers : MemberDeclarationSyntax array -> ^T) (input, [|member'|]))
   
  
positive.code:     | [] -> failwith "No identifiers provided"
      | first::rest -> dottedMemberAccess rest (identifier first)
  
  let staticMemberAccess (``member``:string) (``type`` : TypeSyntax) =
      ``type``
  
  let simpleMemberAccess (id:string) (``member``:string) =
      (identifier id) |> memberAccess  ``member``
  
  let thisMemberAccess (``member``:string) =
      SyntaxFactory.ThisExpression() |> memberAccess ``member``
  
  let objectCreation createdType argumentExpressions =
      let args = argumentExpressions |> Array.map (fun a -> SyntaxFactory.Argument(a))
      let argList = SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList<ArgumentSyntax>(args))
  
negative.code:     /// Unary operator to convert C# Task<'t> to F# Async<'t>
      let (!!) t = Async.AwaitTask t
  
  type TypeSyntax with
      static member Object = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword))
      static member String = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword))
      static member Int = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))
      static member Bool = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword))
      static member FromType (t:System.Type) = SyntaxFactory.ParseTypeName(t.FullName)
  
  module Literal = 
      let Null = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)
      let True = SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)
      let False = SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression)
      let Bool (b:bool) = if b then True else False
     
      let String (s:string) =
          SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(s))
      let EmptyString = String ""
  
      let Int (i:int) =
          SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(i))
      let Zero = Int 0
  
  let addUsings (usings : string array) (compilationUnit : CompilationUnitSyntax) =
      let directives = usings |> Array.map (fun name ->
          SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName(name)))
  
      compilationUnit.AddUsings(directives)
  
  let inline addModifiers syntaxKinds (input:^T) =
      let tokens = syntaxKinds |> Array.map (fun k -> SyntaxFactory.Token(k))
  