anchor.diff:              printer.Print(expr)
               printer.Print(")")
   
  -        member printer.SequenceExpressionWithParens(expr: Expression) =
  -            match expr with
  -            | SequenceExpression(_) -> printer.WithParens(expr)
  -            | _ -> printer.Print(expr)
  -
           /// Surround with parens anything that can potentially conflict with operator precedence
           member printer.ComplexExpressionWithParens(expr: Expression) =
               match expr with
  
positive.code:                 printer.Print(";")
                  printer.PrintNewLine()
  
          member _.IsProductiveStatement(s: Statement) =
              let rec hasNoSideEffects (e: Expression) =
                  match e with
                  | Undefined(_)
                  | Literal(NullLiteral(_))
                  | Literal(Literal.StringLiteral(_))
                  | Literal(BooleanLiteral(_))
                  | Literal(NumericLiteral(_)) -> true
                  // Constructors of classes deriving from System.Object add an empty object at the end
                  | ObjectExpression(properties, loc) -> properties.Length = 0
                  | UnaryExpression(prefix, argument, operator, loc) when operator = "void" -> hasNoSideEffects argument
                  // Some identifiers may be stranded as the result of imports
                  // intended only for side effects, see #2228
                  | Expression.Identifier(_) -> true
                  | _ -> false
  
              match s with
              | ExpressionStatement(expr) -> hasNoSideEffects expr |> not
              | _ -> true
  
          member printer.PrintProductiveStatement(s: Statement, ?printSeparator) =
  
negative.code:                 | Some e ->
                      printer.Print(" = ")
                      if canConflict then printer.ComplexExpressionWithParens(e)
                      else printer.Print(e)
                  if i < declarations.Length - 1 then
                      printer.Print(", ")
  
  