anchor.diff:          let genArgs = transformGenArgs com ctx genArgs
           let path = makeFullNamePath ent.FullName genArgs
           let expr = mkStructExpr path fields // TODO: range
  -        if isStruct || isCopyableEntity com Set.empty ent
  +        if ent.IsValueType
           then expr
           else expr |> maybeWrapSmartPtr ent
   
  
positive.code:         | Fable.NewTuple (values, isStruct) -> makeTuple com ctx r isStruct values
          | Fable.NewList (headAndTail, typ) -> makeList com ctx r typ headAndTail
          | Fable.NewOption (value, typ, isStruct) -> makeOption com ctx r typ value isStruct
          | Fable.NewRecord (values, entRef, genArgs) ->
              let isStruct = (com.GetEntity entRef).IsValueType
              makeRecord com ctx r isStruct values entRef genArgs
          | Fable.NewAnonymousRecord (values, fieldNames, genArgs, isStruct) -> makeTuple com ctx r isStruct values
          | Fable.NewUnion (values, tag, entRef, genArgs) ->
              makeUnion com ctx r values tag entRef genArgs
  
      let calcVarAttrsAndOnlyRef com ctx (e: Fable.Expr) =
          let t = e.Type
  
negative.code:                                     when sameEvalExprs evalExpr evalExpr2 ->
                  match treeExpr with
                  | Fable.DecisionTreeSuccess(defaultTargetIndex, defaultBoundValues, _) ->
                      let cases = (caseExpr, targetIndex, boundValues) :: cases
                      Some(evalExpr, List.rev cases, (defaultTargetIndex, defaultBoundValues))
                  | treeExpr ->
                      let cases = (caseExpr, targetIndex, boundValues) :: cases
                      checkInner cases evalExpr treeExpr
              | Fable.DecisionTreeSuccess(defaultTargetIndex, defaultBoundValues, _) ->
                  Some(evalExpr, List.rev cases, (defaultTargetIndex, defaultBoundValues))
              | _ -> None
          match expr with
          | Fable.IfThenElse(Equals(evalExpr, caseExpr),
                             Fable.DecisionTreeSuccess(targetIndex, boundValues, _), treeExpr, _) ->
              let cases = [(caseExpr, targetIndex, boundValues)]
              checkInner cases evalExpr treeExpr
          | _ -> None
  
      let transformDecisionTreeAsExpr (com: IRustCompiler) ctx targets (expr: Fable.Expr): Rust.Expr =
  