Unify precedence of ++, --, **, .., <> ops

Author: José Valim

lib/elixir/lib/macro.ex

@@ -41,11 +41,9 @@ defmodule Macro do
       o when o in [:==, :!=, :<, :<=, :>=, :>, :=~, :===, :!==] -> {:left, 150}
       o when o in [:<-, :|>, :<<<, :>>>]                        -> {:right, 160}
       :in                                                       -> {:left, 170}
-      :..                                                       -> {:left, 200}
+      o when o in [:++, :--, :**, :.., :<>]                     -> {:right, 200}
       o when o in [:+, :-]                                      -> {:left, 210}
       o when o in [:*, :/]                                      -> {:left, 220}
-      o when o in [:<>]                                         -> {:right, 230}
-      o when o in [:++, :--, :**]                               -> {:right, 240}
       :^^^                                                      -> {:left, 250}
       :.                                                        -> {:left, 310}
     end

lib/elixir/src/elixir_parser.yrl

@@ -5,7 +5,7 @@ Nonterminals
   op_expr matched_op_expr no_parens_op_expr
   comp_op_eol at_op_eol unary_op_eol and_op_eol or_op_eol tail_op_eol
   add_op_eol mult_op_eol exp_op_eol two_op_eol type_op_eol stab_op_eol
-  arrow_op_eol range_op_eol than_op_eol default_op_eol match_op_eol
+  arrow_op_eol default_op_eol match_op_eol
   when_op_eol in_op_eol inc_op_eol
   open_paren close_paren empty_paren
   open_bracket close_bracket
@@ -31,7 +31,7 @@ Terminals
   number signed_number atom atom_string bin_string list_string sigil
   dot_call_op op_identifier
   comp_op at_op unary_op and_op or_op arrow_op match_op
-  range_op in_op inc_op when_op than_op default_op tail_op
+  in_op inc_op when_op default_op tail_op
   dual_op add_op mult_op exp_op two_op type_op stab_op
   'true' 'false' 'nil' 'do' eol ',' '.' '&'
   '(' ')' '[' ']' '{' '}' '<<' '>>'
@@ -57,11 +57,9 @@ Left     140 and_op_eol.      %% &&, &&&, and
 Left     150 comp_op_eol.     %% <, >, <=, >=, ==, !=, =~, ===, !==
 Right    160 arrow_op_eol.    %% < (op), (op) > (e.g <-, |>, <<<, >>>)
 Left     170 in_op_eol.       %% in
-Left     200 range_op_eol.    %% ..
+Right    200 two_op_eol.      %% ++, --, **, .., <>
 Left     210 add_op_eol.      %% + (op), - (op)
 Left     220 mult_op_eol.     %% * (op), / (op)
-Right    230 than_op_eol.     %% < (op) > (e.g <>)
-Right    240 two_op_eol.      %% ++, --, **
 Left     250 exp_op_eol.      %% ^ (op) (e.g ^^^)
 Nonassoc 300 unary_op_eol.    %% +, -, !, ^, not, &, ~~~
 Left     310 dot_call_op.
@@ -141,11 +139,9 @@ op_expr -> two_op_eol expr : { '$1', '$2' }.
 op_expr -> and_op_eol expr : { '$1', '$2' }.
 op_expr -> or_op_eol expr : { '$1', '$2' }.
 op_expr -> tail_op_eol expr : { '$1', '$2' }.
-op_expr -> than_op_eol expr : { '$1', '$2' }.
 op_expr -> in_op_eol expr : { '$1', '$2' }.
 op_expr -> inc_op_eol expr : { '$1', '$2' }.
 op_expr -> when_op_eol expr : { '$1', '$2' }.
-op_expr -> range_op_eol expr : { '$1', '$2' }.
 op_expr -> default_op_eol expr : { '$1', '$2' }.
 op_expr -> type_op_eol expr : { '$1', '$2' }.
 op_expr -> comp_op_eol expr : { '$1', '$2' }.
@@ -159,10 +155,8 @@ no_parens_op_expr -> two_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> and_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> or_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> tail_op_eol no_parens_expr : { '$1', '$2' }.
-no_parens_op_expr -> than_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> in_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> inc_op_eol no_parens_expr : { '$1', '$2' }.
-no_parens_op_expr -> range_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> default_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> type_op_eol no_parens_expr : { '$1', '$2' }.
 no_parens_op_expr -> comp_op_eol no_parens_expr : { '$1', '$2' }.
@@ -180,11 +174,9 @@ matched_op_expr -> two_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> and_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> or_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> tail_op_eol matched_expr : { '$1', '$2' }.
-matched_op_expr -> than_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> in_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> inc_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> when_op_eol matched_expr : { '$1', '$2' }.
-matched_op_expr -> range_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> default_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> type_op_eol matched_expr : { '$1', '$2' }.
 matched_op_expr -> comp_op_eol matched_expr : { '$1', '$2' }.
@@ -338,9 +330,6 @@ or_op_eol -> or_op eol : '$1'.
 tail_op_eol -> tail_op : '$1'.
 tail_op_eol -> tail_op eol : '$1'.
 
-than_op_eol -> than_op : '$1'.
-than_op_eol -> than_op eol : '$1'.
-
 in_op_eol -> in_op : '$1'.
 in_op_eol -> in_op eol : '$1'.
 
@@ -353,9 +342,6 @@ when_op_eol -> when_op eol : '$1'.
 stab_op_eol -> stab_op : '$1'.
 stab_op_eol -> stab_op eol : '$1'.
 
-range_op_eol -> range_op : '$1'.
-range_op_eol -> range_op eol : '$1'.
-
 at_op_eol -> at_op : '$1'.
 at_op_eol -> at_op eol : '$1'.
 

lib/elixir/src/elixir_tokenizer.erl

@@ -25,20 +25,16 @@
 -define(two_op(T1, T2),
   T1 == $+, T2 == $+;
   T1 == $-, T2 == $-;
-  T1 == $*, T2 == $*).
-
--define(than_op(T1, T2),
-  T1 == $<, T2 == $>).
+  T1 == $*, T2 == $*;
+  T1 == $<, T2 == $>;
+  T1 == $., T2 == $.).
 
 -define(mult_op(T),
   T == $* orelse T == $/).
 
 -define(dual_op(T),
   T == $+ orelse T == $-).
 
--define(range_op(T1, T2),
-  T1 == $., T2 == $.).
-
 -define(arrow_op3(T1, T2, T3),
   T1 == $<, T2 == $<, T3 == $<;
   T1 == $>, T2 == $>, T3 == $>).
@@ -244,8 +240,7 @@ tokenize([$.,T1,T2,T3|Rest], Line, Scope, Tokens) when
 % ## Two Token Operators
 tokenize([$.,T1,T2|Rest], Line, Scope, Tokens) when
     ?comp_op2(T1, T2); ?and_op(T1, T2); ?or_op(T1, T2); ?arrow_op(T1, T2);
-    ?range_op(T1, T2); ?than_op(T1, T2); ?default_op(T1, T2); ?two_op(T1, T2);
-    ?stab_op(T1, T2); ?type_op(T1, T2) ->
+    ?default_op(T1, T2); ?two_op(T1, T2); ?stab_op(T1, T2); ?type_op(T1, T2) ->
   handle_call_identifier(Rest, Line, list_to_atom([T1, T2]), Scope, Tokens);
 
 % ## Single Token Operators
@@ -331,8 +326,7 @@ tokenize([$:,T1,T2,T3|Rest], Line, Scope, Tokens) when
 % ## Two Token Operators
 tokenize([$:,T1,T2|Rest], Line, Scope, Tokens) when
     ?comp_op2(T1, T2); ?and_op(T1, T2); ?or_op(T1, T2); ?arrow_op(T1, T2);
-    ?range_op(T1, T2); ?than_op(T1, T2); ?default_op(T1, T2); ?two_op(T1, T2);
-    ?stab_op(T1, T2); ?type_op(T1, T2) ->
+    ?default_op(T1, T2); ?two_op(T1, T2); ?stab_op(T1, T2); ?type_op(T1, T2) ->
   tokenize(Rest, Line, Scope, [{ atom, Line, list_to_atom([T1,T2]) }|Tokens]);
 
 % ## Single Token Operators
@@ -396,12 +390,6 @@ tokenize([T|Rest], Line, Scope, Tokens) when T == $(;
 tokenize([T1,T2|Rest], Line, Scope, Tokens) when ?two_op(T1, T2) ->
   handle_op(Rest, Line, two_op, list_to_atom([T1, T2]), Scope, Tokens);
 
-tokenize([T1,T2|Rest], Line, Scope, Tokens) when ?than_op(T1, T2) ->
-  handle_op(Rest, Line, than_op, list_to_atom([T1, T2]), Scope, Tokens);
-
-tokenize([T1,T2|Rest], Line, Scope, Tokens) when ?range_op(T1, T2) ->
-  handle_op(Rest, Line, range_op, list_to_atom([T1, T2]), Scope, Tokens);
-
 tokenize([T1,T2|Rest], Line, Scope, Tokens) when ?arrow_op(T1, T2) ->
   handle_op(Rest, Line, arrow_op, list_to_atom([T1, T2]), Scope, Tokens);