anchor.diff:  
           let baseExpr, consBody =
               classDecl.BaseCall
  -            |> Option.map (extractBaseExprFromBaseCall com ctx)
  +            |> extractBaseExprFromBaseCall com ctx classEnt.BaseType
               |> Option.orElseWith (fun () ->
                   if classEnt.IsValueType then Some(libValue com ctx "Types" "Record", [])
                   else None)
  
positive.code:         let enumerator = CallExpression(get None (Identifier "this") "GetEnumerator", [||]) :> Expression
          BlockStatement [|ReturnStatement(libCall com ctx None "Seq" "toIterator" [|enumerator|])|]
  
      let extractBaseExprFromBaseCall com ctx baseCall =
          let baseRef, args, hasSpread =
              match baseCall with
              | Fable.Call(baseRef, info, _, _) ->
                  baseRef, info.Args, info.HasSpread
              | _ ->
                  "Unexpected base call expression, please report"
                  |> addError com [] baseCall.Range
                  Fable.Value(Fable.UnitConstant, None), [], false
  
          let baseExpr =
              match baseRef with
              | Fable.IdentExpr id -> typedIdent com ctx id :> Expression
              | _ -> transformAsExpr com ctx baseRef
          let args = transformCallArgs com ctx hasSpread args
          baseExpr, args
  
      let transformObjectExpr (com: IBabelCompiler) ctx (members: Fable.MemberDecl list) baseCall: Expression =
          let compileAsClass =
  
negative.code: 
              let baseExpr, classMembers =
                  baseCall
                  |> extractBaseExprFromBaseCall com ctx None
                  |> Option.map (fun (baseExpr, baseArgs) ->
                      let consBody = BlockStatement [|callSuperAsStatement baseArgs|]
                      let cons = makeClassConstructor [||]  consBody
  