anchor.diff:          let ctx =
               { ctx with TailCallOpportunity = tailcallChance
                          HoistVars = fun ids -> declaredVars.AddRange(ids); true
  -                       OptimizeTailCall = fun () -> isTailCallOptimized <- true }
  +                       OptimizeTailCall = fun () -> isTailCallOptimized <- true
  +                       BoundVars = ctx.BoundVars.EnterScope() }
  +
           let body =
               if body.Type = Fable.Unit then
                   transformBlock com ctx (Some ReturnUnit) body
  
positive.code:         let arguments = Arguments.arguments (self::args)
          FunctionDef.Create(Identifier memb.Name, arguments, body = body)
          |> List.singleton
          //ClassMember.classMethod(kind, key, args, body, computed_=computed, ``static``=isStatic)
  
      let transformAttachedMethod (com: IPythonCompiler) ctx (memb: Fable.MemberDecl) =
          let isStatic = not memb.Info.IsInstance
          let makeMethod name args body =
              let key, computed = memberFromName name
              //ClassMember.classMethod(ClassFunction, key, args, body, computed_=computed, ``static``=isStatic)
              FunctionDef.Create(Identifier name, args, body = body)
          let args, body =
              getMemberArgsAndBody com ctx (Attached isStatic) memb.Info.HasSpread memb.Args memb.Body
  
negative.code:             let args = genArgs |> Array.mapToList (ident >> Arg.arg)
              let expr, stmts' = makeFunctionExpression None (args, body)
              let name = com.GetIdentifier(ctx, entName + Naming.reflectionSuffix)
              expr |> declareModuleMember ctx ent.IsPublic name false, stmts @ stmts'
          stmts @ [typeDeclaration ] @ reflectionDeclaration
  
      let transformModuleFunction (com: IPythonCompiler) ctx (info: Fable.MemberInfo) (membName: string) args body =
          let args, body =
  