From: Yannick Moy Date: Thu, 14 Apr 2022 06:38:29 +0000 (+0200) Subject: [Ada] Issue a warning on entity hidden in use_clause with -gnatwh X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=e1379eeec11098cf8ec006bc0d3ac95beb2ad273;p=platform%2Fupstream%2Fgcc.git [Ada] Issue a warning on entity hidden in use_clause with -gnatwh Augment the warnings issued with switch -gnatwh, so that a warning is also issued when an entity from the package of a use_clause ends up hidden due to an existing visible homonym. gcc/ada/ * sem_ch8.adb (Use_One_Package): Possibly warn. * sem_util.adb (Enter_Name): Factor out warning on hidden entity. (Warn_On_Hiding_Entity): Extract warning logic from Enter_Name and generalize it to be applied also on use_clause. * sem_util.ads (Warn_On_Hiding_Entity): Add new procedure. --- diff --git a/gcc/ada/sem_ch8.adb b/gcc/ada/sem_ch8.adb index 35a9054..80950b8 100644 --- a/gcc/ada/sem_ch8.adb +++ b/gcc/ada/sem_ch8.adb @@ -10326,6 +10326,11 @@ package body Sem_Ch8 is -- Potentially use-visible entity remains hidden + if Warn_On_Hiding then + Warn_On_Hiding_Entity (N, Hidden => Id, Visible => Prev, + On_Use_Clause => True); + end if; + goto Next_Usable_Entity; -- A use clause within an instance hides outer global entities, diff --git a/gcc/ada/sem_util.adb b/gcc/ada/sem_util.adb index 7cfd5f4..92c6636 100644 --- a/gcc/ada/sem_util.adb +++ b/gcc/ada/sem_util.adb @@ -8825,47 +8825,9 @@ package body Sem_Util is -- Warn if new entity hides an old one - if Warn_On_Hiding and then Present (C) - - -- Don't warn for record components since they always have a well - -- defined scope which does not confuse other uses. Note that in - -- some cases, Ekind has not been set yet. - - and then Ekind (C) /= E_Component - and then Ekind (C) /= E_Discriminant - and then Nkind (Parent (C)) /= N_Component_Declaration - and then Ekind (Def_Id) /= E_Component - and then Ekind (Def_Id) /= E_Discriminant - and then Nkind (Parent (Def_Id)) /= N_Component_Declaration - - -- Don't warn for one character variables. It is too common to use - -- such variables as locals and will just cause too many false hits. - - and then Length_Of_Name (Chars (C)) /= 1 - - -- Don't warn for non-source entities - - and then Comes_From_Source (C) - and then Comes_From_Source (Def_Id) - - -- Don't warn within a generic instantiation - - and then not In_Instance - - -- Don't warn unless entity in question is in extended main source - - and then In_Extended_Main_Source_Unit (Def_Id) - - -- Finally, the hidden entity must be either immediately visible or - -- use visible (i.e. from a used package). - - and then - (Is_Immediately_Visible (C) - or else - Is_Potentially_Use_Visible (C)) - then - Error_Msg_Sloc := Sloc (C); - Error_Msg_N ("declaration hides &#?h?", Def_Id); + if Warn_On_Hiding and then Present (C) then + Warn_On_Hiding_Entity (Def_Id, Hidden => C, Visible => Def_Id, + On_Use_Clause => False); end if; end Enter_Name; @@ -30344,6 +30306,69 @@ package body Sem_Util is return List_1; end Visible_Ancestors; + --------------------------- + -- Warn_On_Hiding_Entity -- + --------------------------- + + procedure Warn_On_Hiding_Entity + (N : Node_Id; + Hidden, Visible : Entity_Id; + On_Use_Clause : Boolean) + is + begin + -- Don't warn for record components since they always have a well + -- defined scope which does not confuse other uses. Note that in + -- some cases, Ekind has not been set yet. + + if Ekind (Hidden) /= E_Component + and then Ekind (Hidden) /= E_Discriminant + and then Nkind (Parent (Hidden)) /= N_Component_Declaration + and then Ekind (Visible) /= E_Component + and then Ekind (Visible) /= E_Discriminant + and then Nkind (Parent (Visible)) /= N_Component_Declaration + + -- Don't warn for one character variables. It is too common to use + -- such variables as locals and will just cause too many false hits. + + and then Length_Of_Name (Chars (Hidden)) /= 1 + + -- Don't warn for non-source entities + + and then Comes_From_Source (Hidden) + and then Comes_From_Source (Visible) + + -- Don't warn within a generic instantiation + + and then not In_Instance + + -- Don't warn unless entity in question is in extended main source + + and then In_Extended_Main_Source_Unit (Visible) + + -- Finally, in the case of a declaration, the hidden entity must + -- be either immediately visible or use visible (i.e. from a used + -- package). In the case of a use clause, the visible entity must + -- be immediately visible. + + and then + (if On_Use_Clause then + Is_Immediately_Visible (Visible) + else + (Is_Immediately_Visible (Hidden) + or else + Is_Potentially_Use_Visible (Hidden))) + then + if On_Use_Clause then + Error_Msg_Sloc := Sloc (Visible); + Error_Msg_NE ("visible declaration of&# hides homonym " + & "from use clause?h?", N, Hidden); + else + Error_Msg_Sloc := Sloc (Hidden); + Error_Msg_NE ("declaration hides &#?h?", N, Visible); + end if; + end if; + end Warn_On_Hiding_Entity; + ---------------------- -- Within_Init_Proc -- ---------------------- diff --git a/gcc/ada/sem_util.ads b/gcc/ada/sem_util.ads index 2d9cbd3..bfd952a 100644 --- a/gcc/ada/sem_util.ads +++ b/gcc/ada/sem_util.ads @@ -3453,6 +3453,18 @@ package Sem_Util is function Within_Scope (E : Entity_Id; S : Entity_Id) return Boolean; -- Returns True if entity E is declared within scope S + procedure Warn_On_Hiding_Entity + (N : Node_Id; + Hidden, Visible : Entity_Id; + On_Use_Clause : Boolean); + -- Warn on hiding of an entity, either because a new declaration hides + -- an entity directly visible or potentially visible through a use_clause + -- (On_Use_Clause = False), or because the entity would be potentially + -- visible through a use_clause if it was now hidden by a visible + -- declaration (On_Use_Clause = True). N is the node on which the warning + -- is potentially issued: it is the visible entity in the former case, and + -- the use_clause in the latter case. + procedure Wrong_Type (Expr : Node_Id; Expected_Type : Entity_Id); -- Output error message for incorrectly typed expression. Expr is the node -- for the incorrectly typed construct (Etype (Expr) is the type found),