anchor.diff:                  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
  -
  +        member this.HasSideEffects(e: Expression) =
  +            match e with
  +            | Undefined(_)
  +            | Literal(NullLiteral(_))
  +            | Literal(Literal.StringLiteral(_))
  +            | Literal(BooleanLiteral(_))
  +            | Literal(NumericLiteral(_)) -> false
  +            // 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" -> this.HasSideEffects(argument)
  +            // Some identifiers may be stranded as the result of imports
  +            // intended only for side effects, see #2228
  +            | Expression.Identifier(_) -> false
  +            | _ -> true
  +
  +        member this.IsProductiveStatement(s: Statement) =
               match s with
  -            | ExpressionStatement(expr) -> hasNoSideEffects expr |> not
  +            | ExpressionStatement(expr) -> this.HasSideEffects(expr)
               | _ -> true
   
           member printer.PrintProductiveStatement(s: Statement, ?printSeparator) =
  
positive.code:             | SequenceExpression(expressions, loc) ->
                  // A comma-separated sequence of expressions.
                  printer.AddLocation(loc)
                  printer.PrintCommaSeparatedArray(expressions)
              | FunctionExpression(id, ``params``, body, typeParameters, returnType, loc) ->
                  printer.PrintFunction(id, ``params``, body, returnType, typeParameters, loc)
              | AssignmentExpression(left, right, operator, loc) -> printer.PrintOperation(left, operator, right, loc)
  
negative.code:             printer.PrintArray(nodes, (fun p x -> p.Print(x)), (fun p -> p.Print(", ")))
  
          member printer.PrintCommaSeparatedArray(nodes: Expression array) =
              printer.PrintArray(nodes, (fun p x -> p.Print(x)), (fun p -> p.Print(", ")))
  
  
          // TODO: (super) type parameters, implements
  