anchor.diff:  
       | SynExpr.InterpolatedString (parts, _, m) ->
           checkLanguageFeatureError cenv.g.langVersion LanguageFeature.StringInterpolation m
  -
           CallExprHasTypeSink cenv.tcSink (m, env.NameEnv, overallTy.Commit, env.AccessRights)
  -
           TcInterpolatedStringExpr cenv overallTy env m tpenv parts
   
       | SynExpr.Const (synConst, m) ->
  
positive.code:         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 () ->
          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))
  
  // 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
  
negative.code:         TcExpr cenv overallTy env tpenv (mkSynPrefixPrim opm m (if byref then "~&" else "~&&") synInnerExpr)
  
      | SynExpr.Upcast (synInnerExpr, _, m) | SynExpr.InferredUpcast (synInnerExpr, m) ->
          TcExprUpcast cenv overallTy env tpenv (synExpr, synInnerExpr, m)
  
      | SynExpr.Downcast (synInnerExpr, _, m) | SynExpr.InferredDowncast (synInnerExpr, m) ->
          TcExprDowncast cenv overallTy env tpenv (synExpr, synInnerExpr, m)
  
      | SynExpr.Null m ->
          AddCxTypeMustSupportNull env.DisplayEnv cenv.css m NoTrace overallTy.Commit
          mkNull m overallTy.Commit, tpenv
  
      | SynExpr.Lazy (synInnerExpr, m) ->
          TcExprLazy cenv overallTy env tpenv (synInnerExpr, m)
  
      | SynExpr.Tuple (isExplicitStruct, args, _, m) ->
          TcExprTuple cenv overallTy env tpenv (isExplicitStruct, args, m)
  
      | SynExpr.AnonRecd (isStruct, optOrigExpr, unsortedFieldExprs, mWholeExpr) ->
          TcPossiblyPropogatingExprLeafThenConvert (fun ty -> isAnonRecdTy cenv.g ty || isTyparTy cenv.g ty) cenv overallTy env mWholeExpr (fun overallTy ->
  