anchor.diff:      let block = SyntaxFactory.Block(SyntaxFactory.List<StatementSyntax>(statements))
       (^T : (member WithBody : BlockSyntax -> ^T) (input, block))
   
  -let nullLiteral = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)
  -
  -let stringLiteral (s:string) =
  -    SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(s))
  -
  -let intLiteral (i:int) =
  -    SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(i))
  -
   let setThisMember (memberName:string) value =
       SyntaxFactory.ExpressionStatement(
           SyntaxFactory.AssignmentExpression(
  
positive.code:         )
      )
  
  let memberAccess (``member``:string) (expression:ExpressionSyntax) =
      SyntaxFactory.MemberAccessExpression(
          SyntaxKind.SimpleMemberAccessExpression,
          expression,
          SyntaxFactory.IdentifierName(``member``)
      )
  
  let simpleMemberAccess (identifier:string) (``member``:string) =
      SyntaxFactory.IdentifierName(identifier)
      |> 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))
      SyntaxFactory.ObjectCreationExpression(createdType).WithArgumentList(argList)
negative.code: 
          this.AddUsings(directives)
  
  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))
  
  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 Int (i:int) =
          SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(i))
  
  let inline addModifiers syntaxKinds (input:^T) =
      let tokens = syntaxKinds |> Array.map (fun k -> SyntaxFactory.Token(k))
  