anchor.diff:              let body =
                   //com.TransformAsExpr(ctx, bodyExpr)
                   let usages = calcIdentUsages bodyExpr
  -
  +                let getScope name =
  +                    name, { IsArm = true
  +                            IsRef = true
  +                            IsBox = false
  +                            HasMultipleUses = hasMultipleUses name usages }
                   let symbolsAndNames =
                       let fromIdents =
                           idents
  -                        |> List.map (fun id ->
  -                            id.Name, {  IsArm = true
  -                                        IsRef = true
  -                                        HasMultipleUses = hasMultipleUses id.Name usages })
  -
  +                        |> List.map (fun id -> getScope id.Name)
                       let fromExtra =
                           extraVals
  -                        |> List.map (fun (name, friendlyName, t) ->
  -                            friendlyName, { IsArm = true
  -                                            IsRef = true
  -                                            HasMultipleUses = hasMultipleUses friendlyName usages })
  +                        |> List.map (fun (_name, friendlyName, _t) -> getScope friendlyName)
                       fromIdents @ fromExtra
                   let scopedSymbolsNext =
                       Helpers.Map.merge ctx.ScopedSymbols (symbolsAndNames |> Map.ofList)
  
positive.code:     let transformDecisionTreeSuccessAsExpr (com: IRustCompiler) (ctx: Context) targetIndex boundValues =
          let bindings, target = getDecisionTargetAndBindValues com ctx targetIndex boundValues
          match bindings with
          | [] -> com.TransformAsExpr(ctx, target)
          | bindings ->
              let target = List.rev bindings |> List.fold (fun e (i,v) -> Fable.Let(i,v,e)) target
              com.TransformAsExpr(ctx, target)
  
negative.code:         let allNames = name |> Option.fold (fun xs x -> x :: xs) (argNames @ fixedNames)
          allNames |> Set.ofList
  
      let hasCapturedNames com ctx (name: string) (args: Fable.Ident list) (body: Fable.Expr) =
          let ignoredNames = HashSet(getIgnoredNames (Some name) args)
          let isClosedOver expr =
              isClosedOverIdent com ctx ignoredNames expr |> Option.isSome
          FableTransforms.deepExists isClosedOver body
  