anchor.diff:          let args', tpenv = TcExprsWithFlexes cenv env m tpenv flexes argTys args
           AddCxMethodConstraint env.DisplayEnv cenv.css m NoTrace traitInfo
           Expr.Op (TOp.TraitCall traitInfo, [], args', m), returnTy, tpenv
  -      )
  -
  -    | SynExpr.LibraryOnlyUnionCaseFieldGet (e1, c, n, m) ->
  -      TcNonPropagatingExprLeafThenConvert cenv overallTy env m (fun () ->
  +    )
  +
  +and TcExprUnionCaseFieldGet cenv overallTy env tpenv (e1, c, n, m) =
  +    TcNonPropagatingExprLeafThenConvert cenv overallTy env m (fun () ->
           let e1', ty1, tpenv = TcExprOfUnknownType cenv env tpenv e1
           let mkf, ty2 = TcUnionCaseOrExnField cenv env ty1 m c n
                             ((fun (a, b) n -> mkUnionCaseFieldGetUnproven cenv.g (e1', a, b, n, m)),
                              (fun a n -> mkExnCaseFieldGet(e1', a, n, m)))
           mkf n, ty2, tpenv
  -      )
  -
  -    | SynExpr.LibraryOnlyUnionCaseFieldSet (e1, c, n, e2, m) ->
  -        UnifyTypes cenv env m overallTy.Commit cenv.g.unit_ty
  -        let e1', ty1, tpenv = TcExprOfUnknownType cenv env tpenv e1
  -        let mkf, ty2 = TcUnionCaseOrExnField cenv env ty1 m c n
  -                          ((fun (a, b) n e2' ->
  -                             if not (isUnionCaseFieldMutable cenv.g a n) then errorR(Error(FSComp.SR.tcFieldIsNotMutable(), m))
  -                             mkUnionCaseFieldSet(e1', a, b, n, e2', m)),
  -                           (fun a n e2' ->
  -                             if not (isExnFieldMutable a n) then errorR(Error(FSComp.SR.tcFieldIsNotMutable(), m))
  -                             mkExnCaseFieldSet(e1', a, n, e2', m)))
  -        let e2', tpenv = TcExpr cenv (MustEqual ty2) env tpenv e2
  -        mkf n e2', tpenv
  -
  -    | SynExpr.LibraryOnlyILAssembly (s, tyargs, args, rtys, m) ->
  -        let s = (s :?> ILInstr[])
  -        let argTys = NewInferenceTypes args
  -        let tyargs', tpenv = TcTypes cenv NewTyparsOK CheckCxs ItemOccurence.UseInType env tpenv tyargs
  -        // No subsumption at uses of IL assembly code
  -        let flexes = argTys |> List.map (fun _ -> false)
  -        let args', tpenv = TcExprsWithFlexes cenv env m tpenv flexes argTys args
  -        let rtys', tpenv = TcTypes cenv NewTyparsOK CheckCxs ItemOccurence.UseInType env tpenv rtys
  -        let returnTy =
  -            match rtys' with
  -            | [] -> cenv.g.unit_ty
  -            | [ returnTy ] -> returnTy
  -            | _ -> error(InternalError("Only zero or one pushed items are permitted in IL assembly code", m))
  -        UnifyTypes cenv env m overallTy.Commit returnTy
  -        mkAsmExpr (Array.toList s, tyargs', args', rtys', m), tpenv
  -
  -    | SynExpr.Quote (oper, raw, ast, isFromQueryExpression, m) ->
  -        CallExprHasTypeSink cenv.tcSink (m, env.NameEnv, overallTy.Commit, env.AccessRights)
  -        TcQuotationExpr cenv overallTy env tpenv (oper, raw, ast, isFromQueryExpression, m)
  -
  -    | SynExpr.YieldOrReturn ((isTrueYield, _), _, m)
  -    | SynExpr.YieldOrReturnFrom ((isTrueYield, _), _, m) when isTrueYield ->
  -        error(Error(FSComp.SR.tcConstructRequiresListArrayOrSequence(), m))
  -
  -    | SynExpr.YieldOrReturn ((_, isTrueReturn), _, m)
  -    | SynExpr.YieldOrReturnFrom ((_, isTrueReturn), _, m) when isTrueReturn ->
  -        error(Error(FSComp.SR.tcConstructRequiresComputationExpressions(), m))
  -
  -    | SynExpr.YieldOrReturn (_, _, m)
  -    | SynExpr.YieldOrReturnFrom (_, _, m)
  -    | SynExpr.ImplicitZero m ->
  -        error(Error(FSComp.SR.tcConstructRequiresSequenceOrComputations(), m))
  -
  -    | SynExpr.DoBang (_, m)
  -    | SynExpr.LetOrUseBang  (range=m) ->
  -        error(Error(FSComp.SR.tcConstructRequiresComputationExpression(), m))
  -
  -    | SynExpr.MatchBang (_, _, _, m) ->
  -        error(Error(FSComp.SR.tcConstructRequiresComputationExpression(), m))
  -
  -    | SynExpr.IndexFromEnd (range=m)
  -    | SynExpr.IndexRange (range=m) ->
  -        error(Error(FSComp.SR.tcInvalidIndexerExpression(), m))
  +    )
  +
  +and TcExprUnionCaseFieldSet cenv overallTy env tpenv (e1, c, n, e2, m) =
  +    UnifyTypes cenv env m overallTy.Commit cenv.g.unit_ty
  +    let e1', ty1, tpenv = TcExprOfUnknownType cenv env tpenv e1
  +    let mkf, ty2 = TcUnionCaseOrExnField cenv env ty1 m c n
  +                        ((fun (a, b) n e2' ->
  +                            if not (isUnionCaseFieldMutable cenv.g a n) then errorR(Error(FSComp.SR.tcFieldIsNotMutable(), m))
  +                            mkUnionCaseFieldSet(e1', a, b, n, e2', m)),
  +                        (fun a n e2' ->
  +                            if not (isExnFieldMutable a n) then errorR(Error(FSComp.SR.tcFieldIsNotMutable(), m))
  +                            mkExnCaseFieldSet(e1', a, n, e2', m)))
  +    let e2', tpenv = TcExpr cenv (MustEqual ty2) env tpenv e2
  +    mkf n e2', tpenv
  +
  +and TcExprILAssembly cenv overallTy env tpenv (s, tyargs, args, rtys, m) =
  +    let s = (s :?> ILInstr[])
  +    let argTys = NewInferenceTypes args
  +    let tyargs', tpenv = TcTypes cenv NewTyparsOK CheckCxs ItemOccurence.UseInType env tpenv tyargs
  +    // No subsumption at uses of IL assembly code
  +    let flexes = argTys |> List.map (fun _ -> false)
  +    let args', tpenv = TcExprsWithFlexes cenv env m tpenv flexes argTys args
  +    let rtys', tpenv = TcTypes cenv NewTyparsOK CheckCxs ItemOccurence.UseInType env tpenv rtys
  +    let returnTy =
  +        match rtys' with
  +        | [] -> cenv.g.unit_ty
  +        | [ returnTy ] -> returnTy
  +        | _ -> error(InternalError("Only zero or one pushed items are permitted in IL assembly code", m))
  +    UnifyTypes cenv env m overallTy.Commit returnTy
  +    mkAsmExpr (Array.toList s, tyargs', args', rtys', m), tpenv
   
   // Converts 'a..b' to a call to the '(..)' operator in FSharp.Core
   // Converts 'a..b..c' to a call to the '(.. ..)' operator in FSharp.Core
  
positive.code: 
      // e: ty
      | SynExpr.Typed (synBodyExpr, synType, m) ->
          let tgtTy, tpenv = TcTypeAndRecover cenv NewTyparsOK CheckCxs ItemOccurence.UseInType env tpenv synType
          UnifyOverallType cenv env m overallTy tgtTy
          let bodyExpr, tpenv = TcExpr cenv (MustConvertTo (false, tgtTy)) env tpenv synBodyExpr
          let bodyExpr2 = TcAdjustExprForTypeDirectedConversions cenv overallTy tgtTy env (* true  *) m bodyExpr
          bodyExpr2, tpenv
  
      // e :? ty
      | SynExpr.TypeTest (synInnerExpr, tgtTy, m) ->
          let innerExpr, srcTy, tpenv = TcExprOfUnknownType cenv env tpenv synInnerExpr
          UnifyTypes cenv env m overallTy.Commit cenv.g.bool_ty
          let tgtTy, tpenv = TcType cenv NewTyparsOK CheckCxs ItemOccurence.UseInType env tpenv tgtTy
          TcRuntimeTypeTest (*isCast*)false (*isOperator*)true cenv env.DisplayEnv m tgtTy srcTy
          let expr = mkCallTypeTest cenv.g m tgtTy innerExpr
          expr, tpenv
  
      // SynExpr.AddressOf is noted in the syntax ast in order to recognize it as concrete type information
      // during type checking, in particular prior to resolving overloads. This helps distinguish
  
negative.code:         let overallExpr = mkLet spMatch mInputExpr matchVal inputExpr matchExpr
          overallExpr, tpenv
  
      | SynExpr.MatchLambda (isExnMatch, mArg, clauses, spMatch, m) ->
          TcExprMatchLambda cenv overallTy env tpenv (isExnMatch, mArg, clauses, spMatch, m)
  
      | SynExpr.Assert (x, m) ->
          TcAssertExpr cenv overallTy env m tpenv x
  