anchor.diff:              "Unresolved call detected in Babel pass"
               |> addErrorAndReturnNull com ctx.file.SourcePath range
   
  -    let block r statements =
  -        BlockStatement(statements, ?loc=r)
  -
       // When expecting a block, it's usually not necessary to wrap it
       // in a lambda to isolate its variable context
       let transformBlock (com: IBabelCompiler) ctx ret expr: BlockStatement =
           match ret with
  -        | None -> com.TransformStatement ctx expr |> block expr.Range
  -        | Some ret -> com.TransformExprAndResolve ctx ret expr |> block expr.Range
  +        | None -> com.TransformStatement ctx expr |> BlockStatement
  +        | Some ret -> com.TransformExprAndResolve ctx ret expr |> BlockStatement
   
       let transformSwitch (com: IBabelCompiler) ctx returnStrategy (matchValue, cases, defaultCase) =
           let transformCase test branch =
  
positive.code:         // TODO: Unsigned ints seem to cause problems, should we check only Int32 here?
          | _, Fable.Number(Int8 | Int16 | Int32)
          | _, Fable.EnumType _ ->
              BinaryExpression(BinaryOrBitwise, e, NumericLiteral(0.), ?loc=e.loc)
              :> Expression
          | _ -> e
  
      let transformLambda r args body: Expression =
          match body with
          | U2.Case1 body -> body
          | U2.Case2 e -> BlockStatement([ReturnStatement(e, ?loc=e.loc)], ?loc=e.loc)
          |> fun body -> upcast FunctionExpression (args, body, ?loc=r)
  
      let transformValue (com: IBabelCompiler) (ctx: Context) value: Expression =
          match value with
  
negative.code:         //     //     let value = com.GetImportExpr ctx var.Name path kind
          //     let value = com.TransformExpr ctx value |> wrapIntExpression value.Type
          //     [varDeclaration r (ident var) isMutable value :> Statement]
  
      let rec transformStatement com ctx (expr: Fable.Expr): Statement list =
          match expr with
  