erl_lint: Disallow call to is_record/3 if there is a local is_record/3

Attempting to call is_record/3 (without an erlang: prefix) from a
guard if there was a local function named is_record/3 would cause
a compiler crash. For consistency with other guard tests, disallow
the call.

is_record/2 in a guard will still be allowed (and work correctly)
even if there is a local is_record/2. It could be argued that
is_record/2 should be handled in the same way as is_record/3,
but changing that now could break working code.

lib/stdlib/src/erl_lint.erl

@@ -1808,7 +1808,7 @@ guard_test2({call,Line,{atom,_La,F},As}=G, Vt, St0) ->
     {Asvt,St1} = gexpr_list(As, Vt, St0),       %Always check this.
     A = length(As),
     case erl_internal:type_test(F, A) of
-        true when F =/= is_record ->
+        true when F =/= is_record, A =/= 2 ->
 	    case no_guard_bif_clash(St1, {F,A}) of
 		false ->
 		    {Asvt,add_error(Line, {illegal_guard_local_call,{F,A}}, St1)};
@@ -1872,9 +1872,15 @@ gexpr({call,Line,{atom,_Lr,is_record},[E,R]}, Vt, St0) ->
 gexpr({call,Line,{remote,_Lr,{atom,_Lm,erlang},{atom,Lf,is_record}},[E,A]},
       Vt, St0) ->
     gexpr({call,Line,{atom,Lf,is_record},[E,A]}, Vt, St0);
-gexpr({call,_Line,{atom,_Lr,is_record},[E,{atom,_,_Name},{integer,_,_}]},
+gexpr({call,Line,{atom,_Lr,is_record},[E0,{atom,_,_Name},{integer,_,_}]},
       Vt, St0) ->
-    gexpr(E, Vt, St0);
+    {E,St1} = gexpr(E0, Vt, St0),
+    case no_guard_bif_clash(St0, {is_record,3}) of
+	true ->
+	    {E,St1};
+	false ->
+	    {E,add_error(Line, {illegal_guard_local_call,{is_record,3}}, St1)}
+    end;
 gexpr({call,Line,{atom,_Lr,is_record},[_,_,_]=Asvt0}, Vt, St0) ->
     {Asvt,St1} = gexpr_list(Asvt0, Vt, St0),
     {Asvt,add_error(Line, illegal_guard_expr, St1)};

lib/stdlib/test/erl_lint_SUITE.erl

@@ -2633,22 +2633,33 @@ bif_clash(Config) when is_list(Config) ->
 	   [warn_unused_import],
 	   {warnings,[{2,erl_lint,{redefine_bif_import,{binary_part,3}}}]}},
 	  %% Don't accept call to a guard BIF if there is a local definition
-	  %% or an import with the same name.
+	  %% or an import with the same name. Note: is_record/2 is an
+	  %% exception, since it is more of syntatic sugar than a real BIF.
 	  {clash21,
            <<"-export([is_list/1]).
               -import(x, [is_tuple/1]).
+              -record(r, {a,b}).
               x(T) when is_tuple(T) -> ok;
               x(T) when is_list(T) -> ok.
               y(T) when is_tuple(T) =:= true -> ok;
-              y(T) when is_list(T) =:= true -> ok.
+              y(T) when is_list(T) =:= true -> ok;
+              y(T) when is_record(T, r, 3) -> ok;
+              y(T) when is_record(T, r, 3) =:= true -> ok;
+              y(T) when is_record(T, r) =:= true -> ok.
               is_list(_) ->
                 ok.
+              is_record(_, _) ->
+                ok.
+              is_record(_, _, _) ->
+                ok.
              ">>,
 	   [{no_auto_import,[{is_tuple,1}]}],
-	   {errors,[{3,erl_lint,{illegal_guard_local_call,{is_tuple,1}}},
-		    {4,erl_lint,{illegal_guard_local_call,{is_list,1}}},
-		    {5,erl_lint,{illegal_guard_local_call,{is_tuple,1}}},
-		    {6,erl_lint,{illegal_guard_local_call,{is_list,1}}}],[]}}
+	   {errors,[{4,erl_lint,{illegal_guard_local_call,{is_tuple,1}}},
+		    {5,erl_lint,{illegal_guard_local_call,{is_list,1}}},
+		    {6,erl_lint,{illegal_guard_local_call,{is_tuple,1}}},
+		    {7,erl_lint,{illegal_guard_local_call,{is_list,1}}},
+		    {8,erl_lint,{illegal_guard_local_call,{is_record,3}}},
+		    {9,erl_lint,{illegal_guard_local_call,{is_record,3}}}],[]}}
 	 ],
 
     ?line [] = run(Config, Ts),