anchor.diff:              //         | None -> upcast Babel.NullLiteral ()
               //member _.GetAllImports() = upcast imports.Values
               member bcom.TransformAsExpr(ctx, e) = transformAsExpr bcom ctx e
  -            member bcom.TransformAsStatements(ctx, ret, e) = transformExpressionAsStatements bcom ctx ret e
  -            member bcom.TransformAsStatements(ctx, ret, e) = transformStatementAsStatements bcom ctx ret e
  +
  +            member bcom.TransformAsStatements(ctx, ret, e) =
  +                transformExpressionAsStatements bcom ctx ret e
  +
  +            member bcom.TransformAsStatements(ctx, ret, e) =
  +                transformStatementAsStatements bcom ctx ret e
  +
               member bcom.TransformAsClassDef(ctx, cls) = transformAsClassDef bcom ctx cls
  -        //member bcom.TransformFunction(ctx, name, args, body) = transformFunction bcom ctx name args body
  +            //member bcom.TransformFunction(ctx, name, args, body) = transformFunction bcom ctx name args body
               member bcom.TransformAsImport(ctx, imp) = transformAsImport bcom ctx imp
   
           interface Compiler with
  
positive.code:             [ for st in bl.Body do
                  yield! com.TransformAsStatements(ctx, returnStrategy, st) ]
          | :? Babel.ReturnStatement as rtn ->
              let expr = transformAsExpr com ctx rtn.Argument
              match returnStrategy with
              | Some ReturnStrategy.ReturnUnit -> [ Expr(expr) ]
              | _ -> [ Return expr ]
          | :? Babel.VariableDeclaration as vd ->
              [ for vd in vd.Declarations do
                  let targets: Expression list =
                      [ Name(id = Identifier(vd.Id.Name), ctx = Store()) ]
  
                  match vd.Init with
                  | Some value -> Assign(targets, com.TransformAsExpr(ctx, value))
                  | None -> () ]
  
          | :? Babel.ExpressionStatement as es ->
              // Handle Babel expressions that we need to transforme here as Python statements
              match es.Expression with
              | :? Babel.AssignmentExpression ->
                  com.TransformAsStatements(ctx, returnStrategy, es.Expression)
              | _ ->
                  [ Expr(com.TransformAsExpr(ctx, es.Expression)) ]
          | :? Babel.IfStatement as iff ->
              let test = com.TransformAsExpr(ctx, iff.Test)
              let body = com.TransformAsStatements(ctx, returnStrategy, iff.Consequent)
              let orElse =
                  match iff.Alternate with
                  | Some alt -> com.TransformAsStatements(ctx, returnStrategy, alt)
                  | _ -> []
              [ If(test=test, body=body, orelse=orElse) ]
          | :? Babel.WhileStatement as ws ->
              let test = com.TransformAsExpr(ctx, ws.Test)
              let body = com.TransformAsStatements(ctx, returnStrategy, ws.Body)
  
              [ While(test=test, body=body, orelse=[]) ]
          | _ -> failwith $"transformStatementAsStatements: Unhandled: {stmt}"
  
      /// Transform Babel program to Python module.
  
negative.code:     inherit Compiler
      //abstract GetAllImports: unit -> seq<Python.Import>
      //abstract GetImportExpr: Context * selector: string * path: string * SourceLocation option -> Expression
      abstract TransformAsExpr: Context * Babel.Expression -> Expression * Statement list
      abstract TransformAsStatements: Context * ReturnStrategy option * Babel.Statement -> Statement list
      abstract TransformAsStatements: Context * ReturnStrategy option * Babel.Expression -> Statement list
      abstract TransformAsClassDef: Context * Babel.ClassDeclaration -> Statement
  