Migrate from size to byte_size and tuple_size

Author: José Valim

lib/elixir/lib/io/ansi/docs.ex

@@ -192,7 +192,7 @@ defmodule IO.ANSI.Docs do
     |> handle_links
     |> handle_inline(nil, [], [], options)
     |> String.split(~r{\s})
-    |> write_with_wrap(options[:width] - size(indent), indent, from_list)
+    |> write_with_wrap(options[:width] - byte_size(indent), indent, from_list)
 
     unless from_list, do: IO.puts(IO.ANSI.reset)
   end

lib/elixir/lib/kernel.ex

@@ -2144,7 +2144,7 @@ defmodule Kernel do
   end
 
   defp warn_info([entry|_]) do
-    opts = elem(entry, size(entry) - 1)
+    opts = elem(entry, tuple_size(entry) - 1)
     Exception.format_file_line(Keyword.get(opts, :file), Keyword.get(opts, :line)) <> " "
   end
 

lib/elixir/lib/module.ex

@@ -797,7 +797,7 @@ defmodule Module do
   end
 
   defp warn_info([entry|_]) do
-    opts = elem(entry, size(entry) - 1)
+    opts = elem(entry, tuple_size(entry) - 1)
     Exception.format_file_line(Keyword.get(opts, :file), Keyword.get(opts, :line)) <> " "
   end
 

lib/elixir/lib/string.ex

@@ -1183,8 +1183,8 @@ defmodule String do
   end
 
   defp do_ends_with(string, suffix) when is_binary(suffix) do
-    string_size = size(string)
-    suffix_size = size(suffix)
+    string_size = byte_size(string)
+    suffix_size = byte_size(suffix)
     scope = {string_size - suffix_size, suffix_size}
     (suffix_size <= string_size) and (:nomatch != :binary.match(string, suffix, [scope: scope]))
   end

lib/elixir/lib/string_io.ex

@@ -199,7 +199,7 @@ defmodule StringIO do
   end
 
   defp do_get_chars(input, :latin1, n) do
-    << chars :: [ binary, size(n) ], rest :: binary >> = input
+    <<chars :: [binary, size(n)], rest :: binary>> = input
     {chars, rest}
   end
 
@@ -209,7 +209,7 @@ defmodule StringIO do
         {buf_count, split_pos} when buf_count < n or split_pos == :none ->
           {input, ""}
         {_buf_count, split_pos} ->
-          << chars :: [ binary, size(split_pos) ], rest :: binary >> = input
+          <<chars :: [binary, size(split_pos)], rest :: binary>> = input
           {chars, rest}
       end
     catch

lib/elixir/lib/uri.ex

@@ -267,7 +267,7 @@ defmodule URI do
   # to replace those with nil for consistency.
   defp nillify(l) do
     for s <- l do
-      if size(s) > 0, do: s, else: nil
+      if byte_size(s) > 0, do: s, else: nil
     end
   end
 end

lib/elixir/test/elixir/kernel/binary_test.exs

@@ -42,7 +42,7 @@ bar """
   end
 
   test :utf8 do
-    assert size(" ゆんゆん") == 13
+    assert byte_size(" ゆんゆん") == 13
   end
 
   test :utf8_char do

lib/elixir/test/elixir/kernel/quote_test.exs

@@ -348,63 +348,63 @@ end
 defmodule Kernel.QuoteTest.ImportsHygieneTest do
   use ExUnit.Case, async: true
 
-  defmacrop get_bin_size do
+  defmacrop get_list_length do
     quote do
-      size("hello")
+      length('hello')
     end
   end
 
-  defmacrop get_bin_size_with_partial do
+  defmacrop get_list_length_with_partial do
     quote do
-      (&size(&1)).("hello")
+      (&length(&1)).('hello')
     end
   end
 
-  defmacrop get_bin_size_with_function do
+  defmacrop get_list_length_with_function do
     quote do
-      (&size/1).("hello")
+      (&length/1).('hello')
     end
   end
 
   test :expand_imports do
-    import Kernel, except: [size: 1]
-    assert get_bin_size == 5
-    assert get_bin_size_with_partial == 5
-    assert get_bin_size_with_function == 5
+    import Kernel, except: [length: 1]
+    assert get_list_length == 5
+    assert get_list_length_with_partial == 5
+    assert get_list_length_with_function == 5
   end
 
-  defmacrop get_dict_size do
-    import Kernel, except: [size: 1]
+  defmacrop get_string_length do
+    import Kernel, except: [length: 1]
 
     quote do
-      size([a: 1, b: 2])
+      length("hello")
     end
   end
 
   test :lazy_expand_imports do
-    import Kernel, except: [size: 1]
-    import Dict, only: [size: 1]
-    assert get_dict_size == 2
+    import Kernel, except: [length: 1]
+    import String, only: [length: 1]
+    assert get_string_length == 5
   end
 
   test :lazy_expand_imports_no_conflicts do
-    import Kernel, except: [size: 1]
-    import Dict, only: [size: 1]
+    import Kernel, except: [length: 1]
+    import String, only: [length: 1]
 
-    assert get_bin_size == 5
-    assert get_bin_size_with_partial == 5
-    assert get_bin_size_with_function == 5
+    assert get_list_length == 5
+    assert get_list_length_with_partial == 5
+    assert get_list_length_with_function == 5
   end
 
-  defmacrop with_size do
+  defmacrop with_length do
     quote do
-      import Kernel, except: [size: 1]
-      import Dict, only: [size: 1]
-      size("foo")
+      import Kernel, except: [length: 1]
+      import String, only: [length: 1]
+      length('hello')
     end
   end
 
   test :explicitly_overridden_imports do
-    assert with_size == 3
+    assert with_length == 5
   end
 end

lib/elixir/unicode/unicode.ex

@@ -21,7 +21,7 @@ defmodule String.Unicode do
       _bidi_mirror, _unicode_1, _iso,
       upper, lower, title ] = :binary.split(line, ";", [:global])
 
-    title = :binary.part(title, 0, size(title) - 1)
+    title = :binary.part(title, 0, byte_size(title) - 1)
 
     cond do
       upper != "" or lower != "" or title != "" ->
@@ -215,35 +215,35 @@ defmodule String.Graphemes do
   # Break on control
   for codepoint <- cluster["CR"] ++ cluster["LF"] ++ cluster["Control"] do
     def next_grapheme(<< unquote(codepoint), rest :: binary >> = string) do
-      {:binary.part(string, 0, unquote(size(codepoint))), rest}
+      {:binary.part(string, 0, unquote(byte_size(codepoint))), rest}
     end
   end
 
   # Break on Prepend*
   # for codepoint <- cluster["Prepend"] do
   #   def next_grapheme(<< unquote(codepoint), rest :: binary >> = string) do
-  #     next_prepend(rest, string, unquote(size(codepoint)))
+  #     next_prepend(rest, string, unquote(byte_size(codepoint)))
   #   end
   # end
 
   # Handle Hangul L
   for codepoint <- cluster["L"] do
     def next_grapheme(<< unquote(codepoint), rest :: binary >> = string) do
-      next_hangul_l(rest, string, unquote(size(codepoint)))
+      next_hangul_l(rest, string, unquote(byte_size(codepoint)))
     end
   end
 
   # Handle Hangul T
   for codepoint <- cluster["T"] do
     def next_grapheme(<< unquote(codepoint), rest :: binary >> = string) do
-      next_hangul_t(rest, string, unquote(size(codepoint)))
+      next_hangul_t(rest, string, unquote(byte_size(codepoint)))
     end
   end
 
   # Handle Regional
   for codepoint <- cluster["Regional_Indicator"] do
     def next_grapheme(<< unquote(codepoint), rest :: binary >> = string) do
-      next_regional(rest, string, unquote(size(codepoint)))
+      next_regional(rest, string, unquote(byte_size(codepoint)))
     end
   end
 
@@ -263,19 +263,19 @@ defmodule String.Graphemes do
   # Handle Hangul L
   for codepoint <- cluster["L"] do
     defp next_hangul_l(<< unquote(codepoint), rest :: binary >>, string, size) do
-      next_hangul_l(rest, string, size + unquote(size(codepoint)))
+      next_hangul_l(rest, string, size + unquote(byte_size(codepoint)))
     end
   end
 
   for codepoint <- cluster["LV"] do
     defp next_hangul_l(<< unquote(codepoint), rest :: binary >>, string, size) do
-      next_hangul_v(rest, string, size + unquote(size(codepoint)))
+      next_hangul_v(rest, string, size + unquote(byte_size(codepoint)))
     end
   end
 
   for codepoint <- cluster["LVT"] do
     defp next_hangul_l(<< unquote(codepoint), rest :: binary >>, string, size) do
-      next_hangul_t(rest, string, size + unquote(size(codepoint)))
+      next_hangul_t(rest, string, size + unquote(byte_size(codepoint)))
     end
   end
 
@@ -286,7 +286,7 @@ defmodule String.Graphemes do
   # Handle Hangul V
   for codepoint <- cluster["V"] do
     defp next_hangul_v(<< unquote(codepoint), rest :: binary >>, string, size) do
-      next_hangul_v(rest, string, size + unquote(size(codepoint)))
+      next_hangul_v(rest, string, size + unquote(byte_size(codepoint)))
     end
   end
 
@@ -297,7 +297,7 @@ defmodule String.Graphemes do
   # Handle Hangul T
   for codepoint <- cluster["T"] do
     defp next_hangul_t(<< unquote(codepoint), rest :: binary >>, string, size) do
-      next_hangul_t(rest, string, size + unquote(size(codepoint)))
+      next_hangul_t(rest, string, size + unquote(byte_size(codepoint)))
     end
   end
 
@@ -308,7 +308,7 @@ defmodule String.Graphemes do
   # Handle regional
   for codepoint <- cluster["Regional_Indicator"] do
     defp next_regional(<< unquote(codepoint), rest :: binary >>, string, size) do
-      next_regional(rest, string, size + unquote(size(codepoint)))
+      next_regional(rest, string, size + unquote(byte_size(codepoint)))
     end
   end
 
@@ -319,7 +319,7 @@ defmodule String.Graphemes do
   # Handle Extend+SpacingMark
   for codepoint <- cluster["Extend"] ++ cluster["SpacingMark"]  do
     defp next_extend(<< unquote(codepoint), rest :: binary >>, string, size) do
-      next_extend(rest, string, size + unquote(size(codepoint)))
+      next_extend(rest, string, size + unquote(byte_size(codepoint)))
     end
   end
 
@@ -330,7 +330,7 @@ defmodule String.Graphemes do
   # Handle Prepend
   # for codepoint <- cluster["Prepend"] do
   #   defp next_prepend(<< unquote(codepoint), rest :: binary >>, string, size) do
-  #     next_prepend(rest, string, size + unquote(size(codepoint)))
+  #     next_prepend(rest, string, size + unquote(byte_size(codepoint)))
   #   end
   # end
   #

lib/iex/lib/iex/autocomplete.ex

@@ -250,10 +250,10 @@ defmodule IEx.Autocomplete do
   end
 
   defp to_hint(%{kind: :module, name: name}, hint) do
-    :binary.part(name, size(hint), size(name) - size(hint)) <> "."
+    :binary.part(name, byte_size(hint), byte_size(name) - byte_size(hint)) <> "."
   end
 
   defp to_hint(%{kind: :function, name: name}, hint) do
-    :binary.part(name, size(hint), size(name) - size(hint))
+    :binary.part(name, byte_size(hint), byte_size(name) - byte_size(hint))
   end
 end