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:         )
  
      | SynExpr.ArrayOrList (isArray, args, m) ->
         CallExprHasTypeSink cenv.tcSink (m, env.NameEnv, overallTy.Commit, env.AccessRights)
         let argty = NewInferenceType ()
         let actualTy = if isArray then mkArrayType cenv.g argty else mkListTy cenv.g argty
  
         // Propagating type directed conversion, e.g. for 
         //     let x : seq<int64>  = [ 1; 2 ]
         // Consider also the case where there is no relation but an op_Implicit is enabled from List<_> to C
         //    let x : C = [ B(); B() ]
  
         TcPropagatingExprLeafThenConvert cenv overallTy actualTy env (* canAdhoc  *) m (fun () ->
  
          // Always allow subsumption if a nominal type is known prior to type checking any arguments
          let flex = not (isTyparTy cenv.g argty)
  
negative.code:         TcRecdExpr cenv overallTy env tpenv (inherits, optOrigExpr, flds, mWholeExpr)
        )
  
  and TcExprWhileLoop cenv overallTy env tpenv (spWhile, synGuardExpr, synBodyExpr, m) =
      UnifyTypes cenv env m overallTy.Commit cenv.g.unit_ty
      let guardExpr, tpenv = TcExpr cenv (MustEqual cenv.g.bool_ty) env tpenv synGuardExpr
      let bodyExpr, tpenv = TcStmt cenv env tpenv synBodyExpr
      mkWhile cenv.g (spWhile, NoSpecialWhileLoopMarker, guardExpr, bodyExpr, m), tpenv
  
  and TcExprIntegerForLoop cenv overallTy env tpenv (spBind, id, start, dir, finish, body, m) =
      UnifyTypes cenv env m overallTy.Commit cenv.g.unit_ty
      let startExpr, tpenv = TcExpr cenv (MustEqual cenv.g.int_ty) env tpenv start
      let finishExpr, tpenv = TcExpr cenv (MustEqual cenv.g.int_ty) env tpenv finish
      let idv, _ = mkLocal id.idRange id.idText cenv.g.int_ty
      let envinner = AddLocalVal cenv.g cenv.tcSink m idv env
  
      // notify name resolution sink about loop variable
      let item = Item.Value(mkLocalValRef idv)
      CallNameResolutionSink cenv.tcSink (idv.Range, env.NameEnv, item, emptyTyparInst, ItemOccurence.Binding, env.AccessRights)
  
      let bodyExpr, tpenv = TcStmt cenv envinner tpenv body
      mkFastForLoop cenv.g (spBind, m, idv, startExpr, dir, finishExpr, bodyExpr), tpenv
  
  and TcExprTryWith cenv overallTy env tpenv (synBodyExpr, _mTryToWith, synWithClauses, mWithToLast, mTryToLast, spTry, spWith) =
      let bodyExpr, tpenv = TcExpr cenv overallTy env tpenv synBodyExpr
      // Compile the pattern twice, once as a List.filter with all succeeding targets returning "1", and once as a proper catch block.
      let filterClauses =
          synWithClauses |> List.map (fun clause ->
              let (SynMatchClause(pat, optWhenExpr, arrow, _, m, _)) = clause
              let oneExpr =  SynExpr.Const (SynConst.Int32 1, m)
              SynMatchClause(pat, optWhenExpr, arrow, oneExpr, m, DebugPointAtTarget.No))
      let checkedFilterClauses, tpenv = TcMatchClauses cenv cenv.g.exn_ty (MustEqual cenv.g.int_ty) env tpenv filterClauses
      let checkedHandlerClauses, tpenv = TcMatchClauses cenv cenv.g.exn_ty overallTy env tpenv synWithClauses
      let v1, filterExpr = CompilePatternForMatchClauses cenv env mWithToLast mWithToLast true FailFilter None cenv.g.exn_ty cenv.g.int_ty checkedFilterClauses
      let v2, handlerExpr = CompilePatternForMatchClauses cenv env mWithToLast mWithToLast true Rethrow None cenv.g.exn_ty overallTy.Commit checkedHandlerClauses
      mkTryWith cenv.g (bodyExpr, v1, filterExpr, v2, handlerExpr, mTryToLast, overallTy.Commit, spTry, spWith), tpenv
  
  and TcExprTryFinally cenv overallTy env tpenv (synBodyExpr, synFinallyExpr, mTryToLast, spTry, spFinally) =
      let bodyExpr, tpenv = TcExpr cenv overallTy env tpenv synBodyExpr
      let finallyExpr, tpenv = TcStmt cenv env tpenv synFinallyExpr
      mkTryFinally cenv.g (bodyExpr, finallyExpr, mTryToLast, overallTy.Commit, spTry, spFinally), tpenv
  
  and TcExprJoinIn cenv overallTy env tpenv (e1, mInToken, e2, mAll) =
      errorR(Error(FSComp.SR.parsUnfinishedExpression("in"), mInToken))
      let _, _, tpenv = suppressErrorReporting (fun () -> TcExprOfUnknownType cenv env tpenv e1)
      let _, _, tpenv = suppressErrorReporting (fun () -> TcExprOfUnknownType cenv env tpenv e2)
      mkDefault(mAll, overallTy.Commit), tpenv
  
  and TcExprSequential cenv overallTy env tpenv (synExpr, sp, dir, synExpr1, synExpr2, m) =
      if dir then
          TcLinearExprs (TcExprThatCanBeCtorBody cenv) cenv env overallTy tpenv false synExpr (fun x -> x)
      else
          // Constructors using "new (...) = <ctor-expr> then <expr>"
          let expr1, tpenv = TcExprThatCanBeCtorBody cenv overallTy env tpenv synExpr1
          if (GetCtorShapeCounter env) <> 1 then
              errorR(Error(FSComp.SR.tcExpressionFormRequiresObjectConstructor(), m))
          let expr2, tpenv = TcStmtThatCantBeCtorBody cenv env tpenv synExpr2
          Expr.Sequential (expr1, expr2, ThenDoSeq, sp, m), tpenv
  
  and TcExprSequentialOrImplicitYield cenv overallTy env tpenv (sp, synExpr1, synExpr2, otherExpr, m) =
      let isStmt, expr1, tpenv = TryTcStmt cenv env tpenv synExpr1
      if isStmt then
          let env = ShrinkContext env m synExpr2.Range
          let expr2, tpenv = TcExprThatCanBeCtorBody cenv overallTy env tpenv synExpr2
          Expr.Sequential(expr1, expr2, NormalSeq, sp, m), tpenv
      else
          // The first expression wasn't unit-typed, so proceed to the alternative interpretation
          // Note a copy of the first expression is embedded in 'otherExpr' and thus
          // this will type-check the first expression over again.
          TcExpr cenv overallTy env tpenv otherExpr
  
  and TcExprStaticOptimization cenv overallTy env tpenv (constraints, e2, e3, m) =
      let constraints', tpenv = List.mapFold (TcStaticOptimizationConstraint cenv env) tpenv constraints
      // Do not force the types of the two expressions to be equal
      // This means uses of this construct have to be very carefully written
      let e2', _, tpenv = TcExprOfUnknownType cenv env tpenv e2
      let e3', tpenv = TcExpr cenv overallTy env tpenv e3
      Expr.StaticOptimization (constraints', e2', e3', m), tpenv
  
  /// e1.longId <- e2
  and TcExprDotSet cenv overallTy env tpenv (e1, lidwd, e2, mStmt) =
      let (LongIdentWithDots(longId, _)) = lidwd
    
      if lidwd.ThereIsAnExtraDotAtTheEnd then
          // just drop rhs on the floor
          let mExprAndDotLookup = unionRanges e1.Range (rangeOfLid longId)
          TcExprThen cenv overallTy env tpenv false e1 [DelayedDotLookup(longId, mExprAndDotLookup)]
      else
          let mExprAndDotLookup = unionRanges e1.Range (rangeOfLid longId)
          TcExprThen cenv overallTy env tpenv false e1 [DelayedDotLookup(longId, mExprAndDotLookup); MakeDelayedSet(e2, mStmt)]
  
  /// e1.longId(e2) <- e3, very rarely used named property setters
  and TcExprDotNamedIndexedPropertySet cenv overallTy env tpenv (e1, lidwd, e2, e3, mStmt) =
      let (LongIdentWithDots(longId, _)) = lidwd
      if lidwd.ThereIsAnExtraDotAtTheEnd then
          // just drop rhs on the floor
          let mExprAndDotLookup = unionRanges e1.Range (rangeOfLid longId)
          TcExprThen cenv overallTy env tpenv false e1 [DelayedDotLookup(longId, mExprAndDotLookup)]
      else
          let mExprAndDotLookup = unionRanges e1.Range (rangeOfLid longId)
          TcExprThen cenv overallTy env tpenv false e1 
              [ DelayedDotLookup(longId, mExprAndDotLookup); 
                DelayedApp(ExprAtomicFlag.Atomic, false, None, e2, mStmt)
                MakeDelayedSet(e3, mStmt)]
  
  and TcExprLongIdentSet cenv overallTy env tpenv (lidwd, e2, m) =
      if lidwd.ThereIsAnExtraDotAtTheEnd then
          // just drop rhs on the floor
          TcLongIdentThen cenv overallTy env tpenv lidwd [ ]
      else
          TcLongIdentThen cenv overallTy env tpenv lidwd [ MakeDelayedSet(e2, m) ]
  
  // Type.Items(e1) <- e2
  and TcExprNamedIndexPropertySet cenv overallTy env tpenv (lidwd, e1, e2, mStmt) =
      if lidwd.ThereIsAnExtraDotAtTheEnd then
          // just drop rhs on the floor
          TcLongIdentThen cenv overallTy env tpenv lidwd [ ]
      else
          TcLongIdentThen cenv overallTy env tpenv lidwd 
              [ DelayedApp(ExprAtomicFlag.Atomic, false, None, e1, mStmt)
                MakeDelayedSet(e2, mStmt) ]
  
  and TcExprTraitCall cenv overallTy env tpenv (tps, memSpfn, arg, m) =
      TcNonPropagatingExprLeafThenConvert cenv overallTy env m (fun () ->
          let synTypes = tps |> List.map (fun tp -> SynType.Var(tp, m))
          let traitInfo, tpenv = TcPseudoMemberSpec cenv NewTyparsOK env synTypes tpenv memSpfn m
          if BakedInTraitConstraintNames.Contains traitInfo.MemberName then
  