anchor.diff:          coreCall_ Any "Util" "comparerFromEqualityComparer" [e]
       let inline makeHashSet forceFSharpMap args =
           makeDictionaryOrHashSet com r t i "Set" forceFSharpMap args
  -    let icall meth =
  -        let info = argInfo thisArg args (Some i.ArgTypes)
  -        instanceCall r t info (makeStrConst meth |> Some)
       match i.CompiledName with
       | ".ctor" ->
           match i.ArgTypes with
  
positive.code:         coreCall_ Any "Util" "comparerFromEqualityComparer" [e]
      let inline makeDic forceFSharpMap args =
          makeDictionaryOrHashSet com r t i "Map" forceFSharpMap args
      let icall meth =
          let info = argInfo thisArg args (Some i.ArgTypes)
          instanceCall r t info (makeStrConst meth |> Some)
      match i.CompiledName with
      | ".ctor" ->
          match i.ArgTypes with
  
negative.code:             fsFormat com r t i thisArg args
      | "get_Length", Some c, _ -> get r t c "length" |> Some
      | "Length", None, [arg] -> get r t arg "length" |> Some
      | "Equals", Some x, [y]
      | "Equals", None, [x; y] ->
          makeEqOp r x y BinaryEqualStrict |> Some
      | "Equals", Some x, [y; kind]
      | "Equals", None, [x; y; kind] ->
          makeEqOp r (coreCall_ (Number Int32) "String" "compare" [x; y; kind]) (makeIntConst 0) BinaryEqualStrict |> Some
      | "Contains", Some c, arg::_ ->
          if (List.length args) > 1 then
              addWarning com r "String.Contains: second argument is ignored"
          makeEqOp r (instanceCall_ (Number Int32) c "indexOf" [arg]) (makeIntConst 0) BinaryGreaterOrEqual |> Some
      | "StartsWith", Some c, [_str] ->
          makeEqOp r (instanceCall_ (Number Int32) c "indexOf" args) (makeIntConst 0) BinaryEqualStrict |> Some
      | "StartsWith", c, [_str; _comp] ->
          coreCall r t "String" "startsWith" c args i.ArgTypes|> Some
      | "Substring", _, _ -> icall r t i thisArg args "substr" |> Some
      | "ToUpper", _, _ -> icall r t i thisArg args "toLocaleUpperCase" |> Some
      | "ToUpperInvariant", _, _ -> icall r t i thisArg args "toUpperCase" |> Some
      | "ToLower", _, _ -> icall r t i thisArg args "toLocaleLowerCase" |> Some
      | "ToLowerInvariant", _, _ -> icall r t i thisArg args "toLowerCase" |> Some
      | "Chars", _, _ -> coreCall r t "String" "getCharAtIndex" thisArg args i.ArgTypes |> Some
      | ("IndexOf" | "LastIndexOf"), _, _ ->
          match args with
          | [ExprType Char]
          | [ExprType String]
          | [ExprType Char; ExprType(Number Int32)]
          | [ExprType String; ExprType(Number Int32)] ->
              Naming.lowerFirst i.CompiledName
              |> icall r t i thisArg args |> Some
          | _ -> "The only extra argument accepted for String.IndexOf/LastIndexOf is startIndex."
                 |> addErrorAndReturnNull com r |> Some
      | ("Trim" | "TrimStart" | "TrimEnd"), Some c, _ ->
          let side =
              match i.CompiledName with
              | "TrimStart" -> "start"
              | "TrimEnd" -> "end"
              | _ -> "both"
          coreCall_ t "String" "trim" (c::(makeStrConst side)::args) |> Some
      | "ToCharArray", Some c, _ ->
          instanceCall_ t c "split" [makeStrConst ""] |> Some
      | ("Iterate" | "IterateIndexed" | "ForAll" | "Exists"), _, _ ->
          // TODO!!! Cast the string to seq<char>
          coreCall r t "Seq" (Naming.lowerFirst i.CompiledName) thisArg args i.ArgTypes |> Some
      | ("Map" | "MapIndexed" | "Collect"), _, _ ->
          // TODO!!! Cast the string to seq<char>
          let name = Naming.lowerFirst i.CompiledName
          emitJs r t [coreCall_ Any "Seq" name args] "Array.from($0).join('')" |> Some
      | "Concat", _, _ ->
          let args =
              if i.DeclaringEntityFullName = "System.String"
              then (makeStrConst "")::args else args
          coreCall_ t "String" "join" args |> Some
      | "Split", Some c, _ ->
          match args with
          // Optimization
          | [] -> instanceCall_ t c "split" [Value(StringConstant " ")] |> Some
          | [Value(StringConstant _) as separator]
          | [Value(NewArray(ArrayValues [separator],_))] ->
              instanceCall_ t c "split" [separator] |> Some
          | [arg1; ExprType(EnumType _) as arg2] ->
              let arg1 =
                  match arg1.Type with
                  | Array _ -> arg1
                  | _ -> Value(NewArray(ArrayValues [arg1], String))
              let args = [arg1; Value(Null Any); arg2]
              coreCall_ t "String" "split" (c::args) |> Some
          | args ->
              coreCall r t "String" "split" thisArg args i.ArgTypes |> Some
      | "Filter", _, _ -> coreCall r t "String" "filter" thisArg args i.ArgTypes |> Some
      | _ -> None
  
  let arrayCons (com: ICompiler) genArg =
  