@@ -367,16 +367,7 @@ defmodule Code.Fragment do
         {{:unquoted_atom, acc}, count}
 
       {:alias, rest, acc, count} ->
-        case strip_spaces(rest, count) do
-          {~c"." ++ rest, count} when rest == [] or hd(rest) != ?. ->
-            nested_alias(rest, count + 1, acc)
-
-          {~c"%" ++ _, count} ->
-            {{:struct, acc}, count + 1}
-
-          _ ->
-            {{:alias, acc}, count}
-        end
+        alias_to_cursor_context(rest, count, acc)
 
       {:identifier, _, acc, count} when call_op? and acc in @textual_operators ->
         {{:operator, acc}, count}
@@ -501,33 +492,42 @@ defmodule Code.Fragment do
     end
   end
 
-  defp nested_alias(rest, count, acc) do
-    {rest, count} = strip_spaces(rest, count)
+  defp alias_to_cursor_context(rest, count, acc) do
+    case strip_spaces(rest, count) do
+      {~c"." ++ rest, count} when rest == [] or hd(rest) != ?. ->
+        nested_alias(rest, count + 1, acc)
 
-    case identifier_to_cursor_context(rest, count, true) do
-      {{:struct, prev}, count} when is_list(prev) ->
-        {{:struct, prev ++ ~c"." ++ acc}, count}
+      {~c"%" ++ _, count} ->
+        {{:struct, acc}, count + 1}
 
-      {{:struct, {:alias, parent, prev}}, count} ->
-        {{:struct, {:alias, parent, prev ++ ~c"." ++ acc}}, count}
+      _ ->
+        {{:alias, acc}, count}
+    end
+  end
 
-      {{:struct, prev}, count} ->
-        {{:struct, {:alias, prev, acc}}, count}
+  # Aliases are handled directly, so we only prepend the previous
+  # segment to acc, instead of appending acc to everything before it
+  defp nested_alias(rest, count, acc) do
+    {rest, count} = strip_spaces(rest, count)
 
-      {{:alias, prev}, count} ->
-        {{:alias, prev ++ ~c"." ++ acc}, count}
+    case identifier(rest, count) do
+      {:alias, rest, prev, count} ->
+        alias_to_cursor_context(rest, count, prev ++ ~c"." ++ acc)
 
-      {{:alias, parent, prev}, count} ->
-        {{:alias, parent, prev ++ ~c"." ++ acc}, count}
+      _ ->
+        case identifier_to_cursor_context(rest, count, true) do
+          {{:struct, prev}, count} ->
+            {{:struct, {:alias, prev, acc}}, count}
 
-      {{:local_or_var, prev}, count} ->
-        {{:alias, {:local_or_var, prev}, acc}, count}
+          {{:local_or_var, prev}, count} ->
+            {{:alias, {:local_or_var, prev}, acc}, count}
 
-      {{:module_attribute, prev}, count} ->
-        {{:alias, {:module_attribute, prev}, acc}, count}
+          {{:module_attribute, prev}, count} ->
+            {{:alias, {:module_attribute, prev}, acc}, count}
 
-      _ ->
-        {:none, 0}
+          _ ->
+            {:none, 0}
+        end
     end
   end
 
 
@@ -202,7 +202,7 @@ defmodule Code.Normalizer do
 
     if args != [] and match?([_ | _], last_arg) and keyword?(last_arg) do
       args = normalize_args(args, state)
-      kw_list = normalize_kw_args(last_arg, state, true)
+      kw_list = normalize_kw_args(last_arg, state, 0)
       {:{}, meta, args ++ kw_list}
     else
       normalize_call(quoted, state)
@@ -214,7 +214,7 @@ defmodule Code.Normalizer do
     value =
       cond do
         keyword?(value) and value != [] ->
-          normalize_kw_args(value, state, true)
+          normalize_kw_args(value, state, 0)
 
         is_list(value) ->
           normalize_literal(value, meta, state)
@@ -286,7 +286,7 @@ defmodule Code.Normalizer do
     state = %{state | parent_meta: meta}
 
     if match?([_ | _], right) and keyword?(right) do
-      {:__block__, meta, [{do_normalize(left, state), normalize_kw_args(right, state, true)}]}
+      {:__block__, meta, [{do_normalize(left, state), normalize_kw_args(right, state, 0)}]}
     else
       {:__block__, meta, [{do_normalize(left, state), do_normalize(right, state)}]}
     end
@@ -317,7 +317,7 @@ defmodule Code.Normalizer do
           meta
         end
 
-      {:__block__, meta, [normalize_kw_args(list, state, false)]}
+      {:__block__, meta, [normalize_kw_args(list, state, keyword_start(list))]}
     end
   end
 
@@ -479,7 +479,7 @@ defmodule Code.Normalizer do
   end
 
   defp normalize_map_args(args, state) do
-    Enum.map(normalize_kw_args(args, state, false), fn
+    Enum.map(normalize_kw_args(args, state, keyword_start(args)), fn
       {:__block__, _, [{_, _} = pair]} -> pair
       pair -> pair
     end)
@@ -512,15 +512,17 @@ defmodule Code.Normalizer do
     {form, meta, leading_args ++ [kw_blocks]}
   end
 
-  defp normalize_kw_args(elems, state, keyword?)
+  # The last argument is how many elements are left until the
+  # trailing keyword list starts (0 if we are already in it)
+  defp normalize_kw_args(elems, state, until_keyword)
 
   defp normalize_kw_args(
-         [{{:__block__, key_meta, [key]}, value} = first | rest] = current,
+         [{{:__block__, key_meta, [key]}, value} = first | rest],
          state,
-         keyword?
+         until_keyword
        )
        when is_atom(key) do
-    keyword? = keyword? or keyword?(current)
+    keyword? = until_keyword == 0
 
     first =
       if key_meta[:format] == :keyword and not keyword? do
@@ -531,11 +533,11 @@ defmodule Code.Normalizer do
         first
       end
 
-    [first | normalize_kw_args(rest, state, keyword?)]
+    [first | normalize_kw_args(rest, state, max(until_keyword - 1, 0))]
   end
 
-  defp normalize_kw_args([{left, right} | rest] = current, state, keyword?) do
-    keyword? = keyword? or keyword?(current)
+  defp normalize_kw_args([{left, right} | rest], state, until_keyword) do
+    keyword? = until_keyword == 0
 
     left =
       if keyword? do
@@ -555,17 +557,27 @@ defmodule Code.Normalizer do
         _ -> {:__block__, meta_line(state), [{left, right}]}
       end
 
-    [pair | normalize_kw_args(rest, state, keyword?)]
+    [pair | normalize_kw_args(rest, state, max(until_keyword - 1, 0))]
   end
 
-  defp normalize_kw_args([first | rest], state, keyword?) do
-    [do_normalize(first, state) | normalize_kw_args(rest, state, keyword?)]
+  defp normalize_kw_args([first | rest], state, until_keyword) do
+    [do_normalize(first, state) | normalize_kw_args(rest, state, max(until_keyword - 1, 0))]
   end
 
-  defp normalize_kw_args([], _state, _keyword?) do
+  defp normalize_kw_args([], _state, _until_keyword) do
     []
   end
 
+  defp keyword_start(list) do
+    length(list) - keyword_suffix_length(:lists.reverse(list), 0)
+  end
+
+  defp keyword_suffix_length([head | tail], acc) do
+    if keyword_pair?(head), do: keyword_suffix_length(tail, acc + 1), else: acc
+  end
+
+  defp keyword_suffix_length([], acc), do: acc
+
   defp normalize_args(args, state) do
     Enum.map(args, &do_normalize(&1, state))
   end
@@ -619,21 +631,20 @@ defmodule Code.Normalizer do
     end
   end
 
-  defp keyword?([{{:__block__, key_meta, [key]}, _} | rest]) when is_atom(key) do
-    if key_meta[:format] == :keyword do
-      keyword?(rest)
-    else
-      false
-    end
+  defp keyword?([head | rest]), do: keyword_pair?(head) and keyword?(rest)
+  defp keyword?([]), do: true
+  defp keyword?(_other), do: false
+
+  defp keyword_pair?({{:__block__, key_meta, [key]}, _}) when is_atom(key) do
+    key_meta[:format] == :keyword
   end
 
-  defp keyword?([{key, _value} | rest]) when is_atom(key) do
+  defp keyword_pair?({key, _value}) when is_atom(key) do
     case Atom.to_charlist(key) do
       ~c"Elixir." ++ _ -> false
-      _ -> keyword?(rest)
+      _ -> true
     end
   end
 
-  defp keyword?([]), do: true
-  defp keyword?(_other), do: false
+  defp keyword_pair?(_other), do: false
 end
@@ -245,6 +245,14 @@ defmodule CodeFragmentTest do
                {:alias, {:local_or_var, ~c"__MODULE__"}, ~c"Wor"}
 
       assert CF.cursor_context("@foo.Wor") == {:alias, {:module_attribute, ~c"foo"}, ~c"Wor"}
+
+      assert CF.cursor_context("Hello.Big.Wor") == {:alias, ~c"Hello.Big.Wor"}
+
+      assert CF.cursor_context("hello.Big.World") ==
+               {:alias, {:local_or_var, ~c"hello"}, ~c"Big.World"}
+
+      assert CF.cursor_context("@foo.Big.Wor") ==
+               {:alias, {:module_attribute, ~c"foo"}, ~c"Big.Wor"}
     end
 
     test "structs" do
@@ -279,6 +287,14 @@ defmodule CodeFragmentTest do
 
       assert CF.cursor_context("%@foo.Wor") ==
                {:struct, {:alias, {:module_attribute, ~c"foo"}, ~c"Wor"}}
+
+      assert CF.cursor_context("%Hello.Big.Wor") == {:struct, ~c"Hello.Big.Wor"}
+
+      assert CF.cursor_context("%__MODULE__.Big.Wor") ==
+               {:struct, {:alias, {:local_or_var, ~c"__MODULE__"}, ~c"Big.Wor"}}
+
+      assert CF.cursor_context("%@foo.Big.Wor") ==
+               {:struct, {:alias, {:module_attribute, ~c"foo"}, ~c"Big.Wor"}}
     end
 
     test "unquoted atom" do
 
@@ -550,6 +550,8 @@ defmodule Code.Normalizer.QuotedASTTest do
       tuple = {{:__block__, [format: :keyword], [:a]}, {:b, [], nil}}
       assert quoted_to_string([tuple, :foo, tuple]) == "[{:a, b}, :foo, a: b]"
       assert quoted_to_string([tuple, :foo, {:c, :d}, tuple]) == "[{:a, b}, :foo, c: :d, a: b]"
+      assert quoted_to_string([{:a, 1}, {:b, 2}, :foo]) == "[{:a, 1}, {:b, 2}, :foo]"
+      assert quoted_to_string([{:a, 1}, :foo, {:b, 2}, {:c, 3}]) == "[{:a, 1}, :foo, b: 2, c: 3]"
 
       # Not keyword lists
       assert quoted_to_string(quote(do: [{binary(), integer()}])) == "[{binary(), integer()}]"