anchor.diff:          let expr, computed = getterByName propName
           MemberExpression(left, expr, computed) :> Expression
   
  -    let getExpr com ctx (TransformExpr com ctx expr) (property: Fable.Expr) =
  -        let property, computed = getterByProp com ctx property
  -        match expr with
  +    let getExpr com ctx (object: Expression) (expr: Fable.Expr) =
  +        let expr, computed = getterByExpr com ctx expr
  +        match object with
           | :? EmptyExpression ->
  -            match property with
  +            match expr with
               | :? StringLiteral as lit ->
                   identFromName lit.value :> Expression
  -            | _ -> property
  -        | _ -> MemberExpression (expr, property, computed) :> Expression
  +            | _ -> expr
  +        | _ -> MemberExpression (object, expr, computed) :> Expression
   
       // let rec tryFindMember (ownerName: string) membName entName decls =
       //     decls |> List.tryPick (function
  
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:         | Fable.Function _ | Fable.ObjectExpr _ | Fable.Operation _ | Fable.Get _  ->
              [ExpressionStatement (com.TransformExpr ctx expr, ?loc=expr.Range) :> Statement]
  
      let rec transformExpr (com: IBabelCompiler) ctx (expr: Fable.Expr): Expression =
          match expr with
          // TODO: Warn an unhandlend cast has reached Babel pass
          | Fable.Cast(expr, _) -> transformExpr com ctx expr
  
          | Fable.Value kind -> transformValue com ctx kind
  
          | Fable.IdentExpr i -> upcast Identifier i.Name
  
          | Fable.Import(memb, path, kind, _) ->
              let memb, parts =
                  let parts = Array.toList(memb.Split('.'))
                  parts.Head, parts.Tail
              com.GetImportExpr ctx memb path kind
              |> Some |> accessExpr parts
  
          | Fable.Function(kind, body) ->
              let args =
                  match kind with
                  | Fable.Lambda arg -> [arg]
                  | Fable.Delegate args -> args
              com.TransformFunction ctx None args body ||> makeAnonymousFunction
  
          | Fable.ObjectExpr (members, r) ->
              transformObjectExpr com ctx members r
  
          | Fable.Operation(opKind, _, range) ->
              transformOperation com ctx range opKind
  
          | Fable.Get(expr, getKind, _, range) ->
              transformGet com ctx range expr getKind
  
          | Fable.IfThenElse (TransformExpr com ctx guardExpr,
                              TransformExpr com ctx thenExpr,
                              TransformExpr com ctx elseExpr) ->
              upcast ConditionalExpression(guardExpr, thenExpr, elseExpr)
  
          | Fable.Set(var, setKind, value, range) ->
              transformSet com ctx range var value setKind
  
          // TODO: Hoist the var declaration to avoid the iife
          // Check also Assignments optimization
          | Fable.Let _ -> iife com ctx expr :> Expression
  
          // These cannot appear in expression position in JS
          // They must be wrapped in a lambda
          | Fable.Debugger _ | Fable.Throw _
          | Fable.Sequential _ | Fable.Loop _
          | Fable.TryCatch _ | Fable.Switch _ ->
              iife com ctx expr :> Expression
  
      // let optimizeTailCall (com: IBabelCompiler) (ctx: Context) (tc: ITailCallOpportunity) args =
      //     ctx.optimizeTailCall()
  