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.
Tested on x86_64-pc-linux-gnu, committed on trunk
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
--- 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
--- 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
--- 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),
