Index: par-labl.adb
===================================================================
--- par-labl.adb	(revision 164000)
+++ par-labl.adb	(working copy)
@@ -378,12 +378,10 @@ procedure Labl is
 
                   --  If the label and the goto are both in the same statement
                   --  list, then we've found a loop. Note that labels and goto
-                  --  statements are always part of some list, so
-                  --  List_Containing always makes sense.
+                  --  statements are always part of some list, so In_Same_List
+                  --  always makes sense.
 
-                  if List_Containing (Node (N)) =
-                     List_Containing (Node (S1))
-                  then
+                  if In_Same_List (Node (N), Node (S1)) then
                      Source := S1;
                      Found  := True;
 
Index: sem_type.adb
===================================================================
--- sem_type.adb	(revision 164000)
+++ sem_type.adb	(working copy)
@@ -1866,6 +1866,7 @@ package body Sem_Type is
             then
                declare
                   Opnd : Node_Id;
+
                begin
                   if Nkind (N) = N_Function_Call then
                      Opnd := First_Actual (N);
@@ -1875,8 +1876,8 @@ package body Sem_Type is
 
                   if Ekind (Etype (Opnd)) = E_Anonymous_Access_Type
                     and then
-                      List_Containing (Parent (Designated_Type (Etype (Opnd))))
-                        = List_Containing (Unit_Declaration_Node (User_Subp))
+                      In_Same_List (Parent (Designated_Type (Etype (Opnd))),
+                                    Unit_Declaration_Node (User_Subp))
                   then
                      if It2.Nam = Predef_Subp then
                         return It1;
Index: nlists.adb
===================================================================
--- nlists.adb	(revision 164000)
+++ nlists.adb	(working copy)
@@ -6,7 +6,7 @@
 --                                                                          --
 --                                 B o d y                                  --
 --                                                                          --
---          Copyright (C) 1992-2009, Free Software Foundation, Inc.         --
+--          Copyright (C) 1992-2010, Free Software Foundation, Inc.         --
 --                                                                          --
 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
 -- terms of the  GNU General Public License as published  by the Free Soft- --
@@ -52,10 +52,10 @@ package body Nlists is
    --  three fields:
 
    type List_Header is record
-      First : Node_Id;
+      First : Node_Or_Entity_Id;
       --  Pointer to first node in list. Empty if list is empty
 
-      Last  : Node_Id;
+      Last : Node_Or_Entity_Id;
       --  Pointer to last node in list. Empty if list is empty
 
       Parent : Node_Id;
@@ -85,16 +85,16 @@ package body Nlists is
    --  list and Prev_Node is Empty at the start of a list.
 
    package Next_Node is new Table.Table (
-      Table_Component_Type => Node_Id,
-      Table_Index_Type     => Node_Id'Base,
+      Table_Component_Type => Node_Or_Entity_Id,
+      Table_Index_Type     => Node_Or_Entity_Id'Base,
       Table_Low_Bound      => First_Node_Id,
       Table_Initial        => Alloc.Orig_Nodes_Initial,
       Table_Increment      => Alloc.Orig_Nodes_Increment,
       Table_Name           => "Next_Node");
 
    package Prev_Node is new Table.Table (
-      Table_Component_Type => Node_Id,
-      Table_Index_Type     => Node_Id'Base,
+      Table_Component_Type => Node_Or_Entity_Id,
+      Table_Index_Type     => Node_Or_Entity_Id'Base,
       Table_Low_Bound      => First_Node_Id,
       Table_Initial        => Alloc.Orig_Nodes_Initial,
       Table_Increment      => Alloc.Orig_Nodes_Increment,
@@ -104,23 +104,23 @@ package body Nlists is
    -- Local Subprograms --
    -----------------------
 
-   procedure Set_First (List : List_Id; To : Node_Id);
+   procedure Set_First (List : List_Id; To : Node_Or_Entity_Id);
    pragma Inline (Set_First);
    --  Sets First field of list header List to reference To
 
-   procedure Set_Last (List : List_Id; To : Node_Id);
+   procedure Set_Last (List : List_Id; To : Node_Or_Entity_Id);
    pragma Inline (Set_Last);
    --  Sets Last field of list header List to reference To
 
-   procedure Set_List_Link (Node : Node_Id; To : List_Id);
+   procedure Set_List_Link (Node : Node_Or_Entity_Id; To : List_Id);
    pragma Inline (Set_List_Link);
    --  Sets list link of Node to list header To
 
-   procedure Set_Next (Node : Node_Id; To : Node_Id);
+   procedure Set_Next (Node : Node_Or_Entity_Id; To : Node_Or_Entity_Id);
    pragma Inline (Set_Next);
    --  Sets the Next_Node pointer for Node to reference To
 
-   procedure Set_Prev (Node : Node_Id; To : Node_Id);
+   procedure Set_Prev (Node : Node_Or_Entity_Id; To : Node_Or_Entity_Id);
    pragma Inline (Set_Prev);
    --  Sets the Prev_Node pointer for Node to reference To
 
@@ -128,8 +128,8 @@ package body Nlists is
    -- Allocate_List_Tables --
    --------------------------
 
-   procedure Allocate_List_Tables (N : Node_Id) is
-      Old_Last : constant Node_Id'Base := Next_Node.Last;
+   procedure Allocate_List_Tables (N : Node_Or_Entity_Id) is
+      Old_Last : constant Node_Or_Entity_Id'Base := Next_Node.Last;
 
    begin
       pragma Assert (N >= Old_Last);
@@ -149,8 +149,8 @@ package body Nlists is
    -- Append --
    ------------
 
-   procedure Append (Node : Node_Id; To : List_Id) is
-      L : constant Node_Id := Last (To);
+   procedure Append (Node : Node_Or_Entity_Id; To : List_Id) is
+      L : constant Node_Or_Entity_Id := Last (To);
 
       procedure Append_Debug;
       pragma Inline (Append_Debug);
@@ -230,9 +230,9 @@ package body Nlists is
 
       else
          declare
-            L : constant Node_Id := Last (To);
-            F : constant Node_Id := First (List);
-            N : Node_Id;
+            L : constant Node_Or_Entity_Id := Last (To);
+            F : constant Node_Or_Entity_Id := First (List);
+            N : Node_Or_Entity_Id;
 
          begin
             pragma Debug (Append_List_Debug);
@@ -272,7 +272,7 @@ package body Nlists is
    -- Append_To --
    ---------------
 
-   procedure Append_To (To : List_Id; Node : Node_Id) is
+   procedure Append_To (To : List_Id; Node : Node_Or_Entity_Id) is
    begin
       Append (Node, To);
    end Append_To;
@@ -281,7 +281,7 @@ package body Nlists is
    -- First --
    -----------
 
-   function First (List : List_Id) return Node_Id is
+   function First (List : List_Id) return Node_Or_Entity_Id is
    begin
       if List = No_List then
          return Empty;
@@ -295,8 +295,8 @@ package body Nlists is
    -- First_Non_Pragma --
    ----------------------
 
-   function First_Non_Pragma (List : List_Id) return Node_Id is
-      N : constant Node_Id := First (List);
+   function First_Non_Pragma (List : List_Id) return Node_Or_Entity_Id is
+      N : constant Node_Or_Entity_Id := First (List);
    begin
       if Nkind (N) /= N_Pragma
            and then
@@ -329,11 +329,22 @@ package body Nlists is
    end Initialize;
 
    ------------------
-   -- Insert_After --
+   -- In_Same_List --
    ------------------
 
-   procedure Insert_After (After : Node_Id; Node : Node_Id) is
+   function In_Same_List (N1, N2 : Node_Or_Entity_Id) return Boolean is
+   begin
+      return List_Containing (N1) = List_Containing (N2);
+   end In_Same_List;
 
+   ------------------
+   -- Insert_After --
+   ------------------
+
+   procedure Insert_After
+     (After : Node_Or_Entity_Id;
+      Node  : Node_Or_Entity_Id)
+   is
       procedure Insert_After_Debug;
       pragma Inline (Insert_After_Debug);
       --  Output debug information if Debug_Flag_N set
@@ -366,8 +377,8 @@ package body Nlists is
       pragma Debug (Insert_After_Debug);
 
       declare
-         Before : constant Node_Id := Next (After);
-         LC     : constant List_Id := List_Containing (After);
+         Before : constant Node_Or_Entity_Id := Next (After);
+         LC     : constant List_Id           := List_Containing (After);
 
       begin
          if Present (Before) then
@@ -390,8 +401,10 @@ package body Nlists is
    -- Insert_Before --
    -------------------
 
-   procedure Insert_Before (Before : Node_Id; Node : Node_Id) is
-
+   procedure Insert_Before
+     (Before : Node_Or_Entity_Id;
+      Node   : Node_Or_Entity_Id)
+   is
       procedure Insert_Before_Debug;
       pragma Inline (Insert_Before_Debug);
       --  Output debug information if Debug_Flag_N set
@@ -424,8 +437,8 @@ package body Nlists is
       pragma Debug (Insert_Before_Debug);
 
       declare
-         After : constant Node_Id := Prev (Before);
-         LC    : constant List_Id := List_Containing (Before);
+         After : constant Node_Or_Entity_Id := Prev (Before);
+         LC    : constant List_Id           := List_Containing (Before);
 
       begin
          if Present (After) then
@@ -448,7 +461,7 @@ package body Nlists is
    -- Insert_List_After --
    -----------------------
 
-   procedure Insert_List_After (After : Node_Id; List : List_Id) is
+   procedure Insert_List_After (After : Node_Or_Entity_Id; List : List_Id) is
 
       procedure Insert_List_After_Debug;
       pragma Inline (Insert_List_After_Debug);
@@ -479,11 +492,11 @@ package body Nlists is
 
       else
          declare
-            Before : constant Node_Id := Next (After);
-            LC     : constant List_Id := List_Containing (After);
-            F      : constant Node_Id := First (List);
-            L      : constant Node_Id := Last (List);
-            N      : Node_Id;
+            Before : constant Node_Or_Entity_Id := Next (After);
+            LC     : constant List_Id           := List_Containing (After);
+            F      : constant Node_Or_Entity_Id := First (List);
+            L      : constant Node_Or_Entity_Id := Last (List);
+            N      : Node_Or_Entity_Id;
 
          begin
             pragma Debug (Insert_List_After_Debug);
@@ -515,7 +528,7 @@ package body Nlists is
    -- Insert_List_Before --
    ------------------------
 
-   procedure Insert_List_Before (Before : Node_Id; List : List_Id) is
+   procedure Insert_List_Before (Before : Node_Or_Entity_Id; List : List_Id) is
 
       procedure Insert_List_Before_Debug;
       pragma Inline (Insert_List_Before_Debug);
@@ -546,11 +559,11 @@ package body Nlists is
 
       else
          declare
-            After : constant Node_Id := Prev (Before);
-            LC    : constant List_Id := List_Containing (Before);
-            F     : constant Node_Id := First (List);
-            L     : constant Node_Id := Last (List);
-            N     : Node_Id;
+            After : constant Node_Or_Entity_Id := Prev (Before);
+            LC    : constant List_Id           := List_Containing (Before);
+            F     : constant Node_Or_Entity_Id := First (List);
+            L     : constant Node_Or_Entity_Id := Last (List);
+            N     : Node_Or_Entity_Id;
 
          begin
             pragma Debug (Insert_List_Before_Debug);
@@ -591,7 +604,7 @@ package body Nlists is
    -- Is_List_Member --
    --------------------
 
-   function Is_List_Member (Node : Node_Id) return Boolean is
+   function Is_List_Member (Node : Node_Or_Entity_Id) return Boolean is
    begin
       return Nodes.Table (Node).In_List;
    end Is_List_Member;
@@ -609,7 +622,7 @@ package body Nlists is
    -- Last --
    ----------
 
-   function Last (List : List_Id) return Node_Id is
+   function Last (List : List_Id) return Node_Or_Entity_Id is
    begin
       pragma Assert (List <= Lists.Last);
       return Lists.Table (List).Last;
@@ -628,8 +641,8 @@ package body Nlists is
    -- Last_Non_Pragma --
    ---------------------
 
-   function Last_Non_Pragma (List : List_Id) return Node_Id is
-      N : constant Node_Id := Last (List);
+   function Last_Non_Pragma (List : List_Id) return Node_Or_Entity_Id is
+      N : constant Node_Or_Entity_Id := Last (List);
    begin
       if Nkind (N) /= N_Pragma then
          return N;
@@ -642,7 +655,7 @@ package body Nlists is
    -- List_Containing --
    ---------------------
 
-   function List_Containing (Node : Node_Id) return List_Id is
+   function List_Containing (Node : Node_Or_Entity_Id) return List_Id is
    begin
       pragma Assert (Is_List_Member (Node));
       return List_Id (Nodes.Table (Node).Link);
@@ -654,7 +667,7 @@ package body Nlists is
 
    function List_Length (List : List_Id) return Nat is
       Result : Nat;
-      Node   : Node_Id;
+      Node   : Node_Or_Entity_Id;
 
    begin
       Result := 0;
@@ -698,7 +711,7 @@ package body Nlists is
 
    function New_Copy_List (List : List_Id) return List_Id is
       NL : List_Id;
-      E  : Node_Id;
+      E  : Node_Or_Entity_Id;
 
    begin
       if List = No_List then
@@ -723,7 +736,7 @@ package body Nlists is
 
    function New_Copy_List_Original (List : List_Id) return List_Id is
       NL : List_Id;
-      E  : Node_Id;
+      E  : Node_Or_Entity_Id;
 
    begin
       if List = No_List then
@@ -790,7 +803,7 @@ package body Nlists is
    --  list directly, rather than first building an empty list and then doing
    --  the insertion, which results in some unnecessary work.
 
-   function New_List (Node : Node_Id) return List_Id is
+   function New_List (Node : Node_Or_Entity_Id) return List_Id is
 
       procedure New_List_Debug;
       pragma Inline (New_List_Debug);
@@ -838,14 +851,21 @@ package body Nlists is
       end if;
    end New_List;
 
-   function New_List (Node1, Node2 : Node_Id) return List_Id is
+   function New_List
+     (Node1 : Node_Or_Entity_Id;
+      Node2 : Node_Or_Entity_Id) return List_Id
+   is
       L : constant List_Id := New_List (Node1);
    begin
       Append (Node2, L);
       return L;
    end New_List;
 
-   function New_List (Node1, Node2, Node3 : Node_Id) return List_Id is
+   function New_List
+     (Node1 : Node_Or_Entity_Id;
+      Node2 : Node_Or_Entity_Id;
+      Node3 : Node_Or_Entity_Id) return List_Id
+   is
       L : constant List_Id := New_List (Node1);
    begin
       Append (Node2, L);
@@ -853,7 +873,12 @@ package body Nlists is
       return L;
    end New_List;
 
-   function New_List (Node1, Node2, Node3, Node4 : Node_Id) return List_Id is
+   function New_List
+     (Node1 : Node_Or_Entity_Id;
+      Node2 : Node_Or_Entity_Id;
+      Node3 : Node_Or_Entity_Id;
+      Node4 : Node_Or_Entity_Id) return List_Id
+   is
       L : constant List_Id := New_List (Node1);
    begin
       Append (Node2, L);
@@ -863,11 +888,11 @@ package body Nlists is
    end New_List;
 
    function New_List
-     (Node1 : Node_Id;
-      Node2 : Node_Id;
-      Node3 : Node_Id;
-      Node4 : Node_Id;
-      Node5 : Node_Id) return List_Id
+     (Node1 : Node_Or_Entity_Id;
+      Node2 : Node_Or_Entity_Id;
+      Node3 : Node_Or_Entity_Id;
+      Node4 : Node_Or_Entity_Id;
+      Node5 : Node_Or_Entity_Id) return List_Id
    is
       L : constant List_Id := New_List (Node1);
    begin
@@ -879,12 +904,12 @@ package body Nlists is
    end New_List;
 
    function New_List
-     (Node1 : Node_Id;
-      Node2 : Node_Id;
-      Node3 : Node_Id;
-      Node4 : Node_Id;
-      Node5 : Node_Id;
-      Node6 : Node_Id) return List_Id
+     (Node1 : Node_Or_Entity_Id;
+      Node2 : Node_Or_Entity_Id;
+      Node3 : Node_Or_Entity_Id;
+      Node4 : Node_Or_Entity_Id;
+      Node5 : Node_Or_Entity_Id;
+      Node6 : Node_Or_Entity_Id) return List_Id
    is
       L : constant List_Id := New_List (Node1);
    begin
@@ -900,13 +925,13 @@ package body Nlists is
    -- Next --
    ----------
 
-   function Next (Node : Node_Id) return Node_Id is
+   function Next (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id is
    begin
       pragma Assert (Is_List_Member (Node));
       return Next_Node.Table (Node);
    end Next;
 
-   procedure Next (Node : in out Node_Id) is
+   procedure Next (Node : in out Node_Or_Entity_Id) is
    begin
       Node := Next (Node);
    end Next;
@@ -924,22 +949,22 @@ package body Nlists is
    -- Next_Non_Pragma --
    ---------------------
 
-   function Next_Non_Pragma (Node : Node_Id) return Node_Id is
-      N : Node_Id;
+   function Next_Non_Pragma
+     (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id
+   is
+      N : Node_Or_Entity_Id;
 
    begin
       N := Node;
       loop
          N := Next (N);
-         exit when Nkind (N) /= N_Pragma
-                     and then
-                   Nkind (N) /= N_Null_Statement;
+         exit when not Nkind_In (N, N_Pragma, N_Null_Statement);
       end loop;
 
       return N;
    end Next_Non_Pragma;
 
-   procedure Next_Non_Pragma (Node : in out Node_Id) is
+   procedure Next_Non_Pragma (Node : in out Node_Or_Entity_Id) is
    begin
       Node := Next_Non_Pragma (Node);
    end Next_Non_Pragma;
@@ -966,10 +991,10 @@ package body Nlists is
    -- p --
    -------
 
-   function p (U : Union_Id) return Node_Id is
+   function p (U : Union_Id) return Node_Or_Entity_Id is
    begin
       if U in Node_Range then
-         return Parent (Node_Id (U));
+         return Parent (Node_Or_Entity_Id (U));
       elsif U in List_Range then
          return Parent (List_Id (U));
       else
@@ -981,7 +1006,7 @@ package body Nlists is
    -- Parent --
    ------------
 
-   function Parent (List : List_Id) return Node_Id is
+   function Parent (List : List_Id) return Node_Or_Entity_Id is
    begin
       pragma Assert (List <= Lists.Last);
       return Lists.Table (List).Parent;
@@ -991,8 +1016,8 @@ package body Nlists is
    -- Pick --
    ----------
 
-   function Pick (List : List_Id; Index : Pos) return Node_Id is
-      Elmt : Node_Id;
+   function Pick (List : List_Id; Index : Pos) return Node_Or_Entity_Id is
+      Elmt : Node_Or_Entity_Id;
 
    begin
       Elmt := First (List);
@@ -1007,8 +1032,8 @@ package body Nlists is
    -- Prepend --
    -------------
 
-   procedure Prepend (Node : Node_Id; To : List_Id) is
-      F : constant Node_Id := First (To);
+   procedure Prepend (Node : Node_Or_Entity_Id; To : List_Id) is
+      F : constant Node_Or_Entity_Id := First (To);
 
       procedure Prepend_Debug;
       pragma Inline (Prepend_Debug);
@@ -1088,9 +1113,9 @@ package body Nlists is
 
       else
          declare
-            F : constant Node_Id := First (To);
-            L : constant Node_Id := Last (List);
-            N : Node_Id;
+            F : constant Node_Or_Entity_Id := First (To);
+            L : constant Node_Or_Entity_Id := Last (List);
+            N : Node_Or_Entity_Id;
 
          begin
             pragma Debug (Prepend_List_Debug);
@@ -1130,7 +1155,7 @@ package body Nlists is
    -- Prepend_To --
    ----------------
 
-   procedure Prepend_To (To : List_Id; Node : Node_Id) is
+   procedure Prepend_To (To : List_Id; Node : Node_Or_Entity_Id) is
    begin
       Prepend (Node, To);
    end Prepend_To;
@@ -1148,13 +1173,13 @@ package body Nlists is
    -- Prev --
    ----------
 
-   function Prev (Node : Node_Id) return Node_Id is
+   function Prev (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id is
    begin
       pragma Assert (Is_List_Member (Node));
       return Prev_Node.Table (Node);
    end Prev;
 
-   procedure Prev (Node : in out Node_Id) is
+   procedure Prev (Node : in out Node_Or_Entity_Id) is
    begin
       Node := Prev (Node);
    end Prev;
@@ -1172,8 +1197,10 @@ package body Nlists is
    -- Prev_Non_Pragma --
    ---------------------
 
-   function Prev_Non_Pragma (Node : Node_Id) return Node_Id is
-      N : Node_Id;
+   function Prev_Non_Pragma
+     (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id
+   is
+      N : Node_Or_Entity_Id;
 
    begin
       N := Node;
@@ -1185,7 +1212,7 @@ package body Nlists is
       return N;
    end Prev_Non_Pragma;
 
-   procedure Prev_Non_Pragma (Node : in out Node_Id) is
+   procedure Prev_Non_Pragma (Node : in out Node_Or_Entity_Id) is
    begin
       Node := Prev_Non_Pragma (Node);
    end Prev_Non_Pragma;
@@ -1194,10 +1221,10 @@ package body Nlists is
    -- Remove --
    ------------
 
-   procedure Remove (Node : Node_Id) is
-      Lst : constant List_Id := List_Containing (Node);
-      Prv : constant Node_Id := Prev (Node);
-      Nxt : constant Node_Id := Next (Node);
+   procedure Remove (Node : Node_Or_Entity_Id) is
+      Lst : constant List_Id           := List_Containing (Node);
+      Prv : constant Node_Or_Entity_Id := Prev (Node);
+      Nxt : constant Node_Or_Entity_Id := Next (Node);
 
       procedure Remove_Debug;
       pragma Inline (Remove_Debug);
@@ -1241,8 +1268,8 @@ package body Nlists is
    -- Remove_Head --
    -----------------
 
-   function Remove_Head (List : List_Id) return Node_Id is
-      Frst : constant Node_Id := First (List);
+   function Remove_Head (List : List_Id) return Node_Or_Entity_Id is
+      Frst : constant Node_Or_Entity_Id := First (List);
 
       procedure Remove_Head_Debug;
       pragma Inline (Remove_Head_Debug);
@@ -1271,7 +1298,7 @@ package body Nlists is
 
       else
          declare
-            Nxt : constant Node_Id := Next (Frst);
+            Nxt : constant Node_Or_Entity_Id := Next (Frst);
 
          begin
             Set_First (List, Nxt);
@@ -1293,8 +1320,10 @@ package body Nlists is
    -- Remove_Next --
    -----------------
 
-   function Remove_Next (Node : Node_Id) return Node_Id is
-      Nxt : constant Node_Id := Next (Node);
+   function Remove_Next
+     (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id
+   is
+      Nxt : constant Node_Or_Entity_Id := Next (Node);
 
       procedure Remove_Next_Debug;
       pragma Inline (Remove_Next_Debug);
@@ -1318,8 +1347,8 @@ package body Nlists is
    begin
       if Present (Nxt) then
          declare
-            Nxt2 : constant Node_Id := Next (Nxt);
-            LC   : constant List_Id := List_Containing (Node);
+            Nxt2 : constant Node_Or_Entity_Id := Next (Nxt);
+            LC   : constant List_Id           := List_Containing (Node);
 
          begin
             pragma Debug (Remove_Next_Debug);
@@ -1343,7 +1372,7 @@ package body Nlists is
    -- Set_First --
    ---------------
 
-   procedure Set_First (List : List_Id; To : Node_Id) is
+   procedure Set_First (List : List_Id; To : Node_Or_Entity_Id) is
    begin
       Lists.Table (List).First := To;
    end Set_First;
@@ -1352,7 +1381,7 @@ package body Nlists is
    -- Set_Last --
    --------------
 
-   procedure Set_Last (List : List_Id; To : Node_Id) is
+   procedure Set_Last (List : List_Id; To : Node_Or_Entity_Id) is
    begin
       Lists.Table (List).Last := To;
    end Set_Last;
@@ -1361,7 +1390,7 @@ package body Nlists is
    -- Set_List_Link --
    -------------------
 
-   procedure Set_List_Link (Node : Node_Id; To : List_Id) is
+   procedure Set_List_Link (Node : Node_Or_Entity_Id; To : List_Id) is
    begin
       Nodes.Table (Node).Link := Union_Id (To);
    end Set_List_Link;
@@ -1370,7 +1399,7 @@ package body Nlists is
    -- Set_Next --
    --------------
 
-   procedure Set_Next (Node : Node_Id; To : Node_Id) is
+   procedure Set_Next (Node : Node_Or_Entity_Id; To : Node_Or_Entity_Id) is
    begin
       Next_Node.Table (Node) := To;
    end Set_Next;
@@ -1379,7 +1408,7 @@ package body Nlists is
    -- Set_Parent --
    ----------------
 
-   procedure Set_Parent (List : List_Id; Node : Node_Id) is
+   procedure Set_Parent (List : List_Id; Node : Node_Or_Entity_Id) is
    begin
       pragma Assert (List <= Lists.Last);
       Lists.Table (List).Parent := Node;
@@ -1389,7 +1418,7 @@ package body Nlists is
    -- Set_Prev --
    --------------
 
-   procedure Set_Prev (Node : Node_Id; To : Node_Id) is
+   procedure Set_Prev (Node : Node_Or_Entity_Id; To : Node_Or_Entity_Id) is
    begin
       Prev_Node.Table (Node) := To;
    end Set_Prev;
Index: nlists.ads
===================================================================
--- nlists.ads	(revision 164000)
+++ nlists.ads	(working copy)
@@ -6,7 +6,7 @@
 --                                                                          --
 --                                 S p e c                                  --
 --                                                                          --
---          Copyright (C) 1992-2009, Free Software Foundation, Inc.         --
+--          Copyright (C) 1992-2010, Free Software Foundation, Inc.         --
 --                                                                          --
 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
 -- terms of the  GNU General Public License as published  by the Free Soft- --
@@ -49,6 +49,10 @@ package Nlists is
    --  Note: node lists can contain either nodes or entities (extended nodes)
    --  or a mixture of nodes and extended nodes.
 
+   function In_Same_List (N1, N2 : Node_Or_Entity_Id) return Boolean;
+   pragma Inline (In_Same_List);
+   --  Equivalent to List_Containing (N1) = List_Containing (N2)
+
    function Last_List_Id return List_Id;
    pragma Inline (Last_List_Id);
    --  Returns Id of last allocated list header
@@ -70,33 +74,42 @@ package Nlists is
    --  Used in contexts where an empty list (as opposed to an initially empty
    --  list to be filled in) is required.
 
-   function New_List (Node : Node_Id) return List_Id;
+   function New_List
+     (Node : Node_Or_Entity_Id) return List_Id;
    --  Build a new list initially containing the given node
 
-   function New_List (Node1, Node2 : Node_Id) return List_Id;
+   function New_List
+     (Node1 : Node_Or_Entity_Id;
+      Node2 : Node_Or_Entity_Id) return List_Id;
    --  Build a new list initially containing the two given nodes
 
-   function New_List (Node1, Node2, Node3 : Node_Id) return List_Id;
+   function New_List
+     (Node1 : Node_Or_Entity_Id;
+      Node2 : Node_Or_Entity_Id;
+      Node3 : Node_Or_Entity_Id) return List_Id;
    --  Build a new list initially containing the three given nodes
 
-   function New_List (Node1, Node2, Node3, Node4 : Node_Id) return List_Id;
-   --  Build a new list initially containing the four given nodes
+   function New_List
+     (Node1 : Node_Or_Entity_Id;
+      Node2 : Node_Or_Entity_Id;
+      Node3 : Node_Or_Entity_Id;
+      Node4 : Node_Or_Entity_Id) return List_Id;
 
    function New_List
-     (Node1 : Node_Id;
-      Node2 : Node_Id;
-      Node3 : Node_Id;
-      Node4 : Node_Id;
-      Node5 : Node_Id) return List_Id;
+     (Node1 : Node_Or_Entity_Id;
+      Node2 : Node_Or_Entity_Id;
+      Node3 : Node_Or_Entity_Id;
+      Node4 : Node_Or_Entity_Id;
+      Node5 : Node_Or_Entity_Id) return List_Id;
    --  Build a new list initially containing the five given nodes
 
    function New_List
-     (Node1 : Node_Id;
-      Node2 : Node_Id;
-      Node3 : Node_Id;
-      Node4 : Node_Id;
-      Node5 : Node_Id;
-      Node6 : Node_Id) return List_Id;
+     (Node1 : Node_Or_Entity_Id;
+      Node2 : Node_Or_Entity_Id;
+      Node3 : Node_Or_Entity_Id;
+      Node4 : Node_Or_Entity_Id;
+      Node5 : Node_Or_Entity_Id;
+      Node6 : Node_Or_Entity_Id) return List_Id;
    --  Build a new list initially containing the six given nodes
 
    function New_Copy_List (List : List_Id) return List_Id;
@@ -108,12 +121,12 @@ package Nlists is
    function New_Copy_List_Original (List : List_Id) return List_Id;
    --  Same as New_Copy_List but copies only nodes coming from source
 
-   function First (List : List_Id) return Node_Id;
+   function First (List : List_Id) return Node_Or_Entity_Id;
    pragma Inline (First);
    --  Obtains the first element of the given node list or, if the node list
    --  has no items or is equal to No_List, then Empty is returned.
 
-   function First_Non_Pragma (List : List_Id) return Node_Id;
+   function First_Non_Pragma (List : List_Id) return Node_Or_Entity_Id;
    --  Used when dealing with a list that can contain pragmas to skip past
    --  any initial pragmas and return the first element that is not a pragma.
    --  If the list is empty, or if it contains only pragmas, then Empty is
@@ -122,14 +135,14 @@ package Nlists is
    --  This function also skips N_Null nodes which can result from rewriting
    --  unrecognized or incorrect pragmas.
 
-   function Last (List : List_Id) return Node_Id;
+   function Last (List : List_Id) return Node_Or_Entity_Id;
    pragma Inline (Last);
    --  Obtains the last element of the given node list or, if the node list
    --  has no items, then Empty is returned. It is an error to call Last with
    --  a Node_Id or No_List. (No_List is not considered to be the same as an
    --  empty node list).
 
-   function Last_Non_Pragma (List : List_Id) return Node_Id;
+   function Last_Non_Pragma (List : List_Id) return Node_Or_Entity_Id;
    --  Obtains the last element of a given node list that is not a pragma.
    --  If the list is empty, or if it contains only pragmas, then Empty is
    --  returned. It is an error to call Last_Non_Pragma with a Node_Id or
@@ -141,42 +154,44 @@ package Nlists is
    --  this function with No_List (No_List is not considered to be the same
    --  as an empty list).
 
-   function Next (Node : Node_Id) return Node_Id;
+   function Next (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id;
    pragma Inline (Next);
    --  This function returns the next node on a node list, or Empty if Node is
    --  the last element of the node list. The argument must be a member of a
    --  node list.
 
-   procedure Next (Node : in out Node_Id);
+   procedure Next (Node : in out Node_Or_Entity_Id);
    pragma Inline (Next);
    --  Equivalent to Node := Next (Node);
 
-   function Next_Non_Pragma (Node : Node_Id) return Node_Id;
+   function Next_Non_Pragma
+     (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id;
    --  This function returns the next node on a node list, skipping past any
    --  pragmas, or Empty if there is no non-pragma entry left. The argument
    --  must be a member of a node list. This function also skips N_Null nodes
    --  which can result from rewriting unrecognized or incorrect pragmas.
 
-   procedure Next_Non_Pragma (Node : in out Node_Id);
+   procedure Next_Non_Pragma (Node : in out Node_Or_Entity_Id);
    pragma Inline (Next_Non_Pragma);
    --  Equivalent to Node := Next_Non_Pragma (Node);
 
-   function Prev (Node : Node_Id) return Node_Id;
+   function Prev (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id;
    pragma Inline (Prev);
    --  This function returns the previous node on a node list, or Empty
    --  if Node is the first element of the node list. The argument must be
    --  a member of a node list. Note: the implementation does maintain back
    --  pointers, so this function executes quickly in constant time.
 
-   function Pick (List : List_Id; Index : Pos) return Node_Id;
+   function Pick (List : List_Id; Index : Pos) return Node_Or_Entity_Id;
    --  Given a list, picks out the Index'th entry (1 = first entry). The
    --  caller must ensure that Index is in range.
 
-   procedure Prev (Node : in out Node_Id);
+   procedure Prev (Node : in out Node_Or_Entity_Id);
    pragma Inline (Prev);
    --  Equivalent to Node := Prev (Node);
 
-   function Prev_Non_Pragma (Node : Node_Id) return Node_Id;
+   function Prev_Non_Pragma
+     (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id;
    pragma Inline (Prev_Non_Pragma);
    --  This function returns the previous node on a node list, skipping any
    --  pragmas. If Node is the first element of the list, or if the only
@@ -185,7 +200,7 @@ package Nlists is
    --  does maintain back pointers, so this function executes quickly in
    --  constant time.
 
-   procedure Prev_Non_Pragma (Node : in out Node_Id);
+   procedure Prev_Non_Pragma (Node : in out Node_Or_Entity_Id);
    pragma Inline (Prev_Non_Pragma);
    --  Equivalent to Node := Prev_Non_Pragma (Node);
 
@@ -199,23 +214,23 @@ package Nlists is
    --  This function determines if a given list id references a node list that
    --  contains at least one item. No_List as an argument returns False.
 
-   function Is_List_Member (Node : Node_Id) return Boolean;
+   function Is_List_Member (Node : Node_Or_Entity_Id) return Boolean;
    pragma Inline (Is_List_Member);
    --  This function determines if a given node is a member of a node list.
    --  It is an error for Node to be Empty, or to be a node list.
 
-   function List_Containing (Node : Node_Id) return List_Id;
+   function List_Containing (Node : Node_Or_Entity_Id) return List_Id;
    pragma Inline (List_Containing);
    --  This function provides a pointer to the node list containing Node.
    --  Node must be a member of a node list.
 
-   procedure Append (Node : Node_Id; To : List_Id);
+   procedure Append (Node : Node_Or_Entity_Id; To : List_Id);
    --  Appends Node at the end of node list To. Node must be a non-empty node
    --  that is not already a member of a node list, and To must be a
    --  node list. An attempt to append an error node is ignored without
    --  complaint and the list is unchanged.
 
-   procedure Append_To (To : List_Id; Node : Node_Id);
+   procedure Append_To (To : List_Id; Node : Node_Or_Entity_Id);
    pragma Inline (Append_To);
    --  Like Append, but arguments are the other way round
 
@@ -227,56 +242,72 @@ package Nlists is
    pragma Inline (Append_List_To);
    --  Like Append_List, but arguments are the other way round
 
-   procedure Insert_After (After : Node_Id; Node : Node_Id);
+   procedure Insert_After
+     (After : Node_Or_Entity_Id;
+      Node  : Node_Or_Entity_Id);
    --  Insert Node, which must be a non-empty node that is not already a
    --  member of a node list, immediately past node After, which must be a
    --  node that is currently a member of a node list. An attempt to insert
    --  an error node is ignored without complaint (and the list is unchanged).
 
-   procedure Insert_List_After (After : Node_Id; List : List_Id);
+   procedure Insert_List_After
+     (After : Node_Or_Entity_Id;
+      List  : List_Id);
    --  Inserts the entire contents of node list List immediately after node
    --  After, which must be a member of a node list. On return, the node list
    --  List is reset to be the empty node list.
 
-   procedure Insert_Before (Before : Node_Id; Node : Node_Id);
+   procedure Insert_Before
+     (Before : Node_Or_Entity_Id;
+      Node   : Node_Or_Entity_Id);
    --  Insert Node, which must be a non-empty node that is not already a
    --  member of a node list, immediately before Before, which must be a node
    --  that is currently a member of a node list. An attempt to insert an
    --  error node is ignored without complaint (and the list is unchanged).
 
-   procedure Insert_List_Before (Before : Node_Id; List : List_Id);
+   procedure Insert_List_Before
+     (Before : Node_Or_Entity_Id;
+      List   : List_Id);
    --  Inserts the entire contents of node list List immediately before node
    --  Before, which must be a member of a node list. On return, the node list
    --  List is reset to be the empty node list.
 
-   procedure Prepend (Node : Node_Id; To : List_Id);
+   procedure Prepend
+     (Node : Node_Or_Entity_Id;
+      To   : List_Id);
    --  Prepends Node at the start of node list To. Node must be a non-empty
    --  node that is not already a member of a node list, and To must be a
    --  node list. An attempt to prepend an error node is ignored without
    --  complaint and the list is unchanged.
 
-   procedure Prepend_To (To : List_Id; Node : Node_Id);
+   procedure Prepend_To
+     (To   : List_Id;
+      Node : Node_Or_Entity_Id);
    pragma Inline (Prepend_To);
    --  Like Prepend, but arguments are the other way round
 
-   procedure Prepend_List (List : List_Id; To : List_Id);
+   procedure Prepend_List
+     (List : List_Id;
+      To   : List_Id);
    --  Prepends node list List to the start of node list To. On return,
    --  List is reset to be empty.
 
-   procedure Prepend_List_To (To : List_Id; List : List_Id);
+   procedure Prepend_List_To
+     (To   : List_Id;
+      List : List_Id);
    pragma Inline (Prepend_List_To);
    --  Like Prepend_List, but arguments are the other way round
 
-   procedure Remove (Node : Node_Id);
+   procedure Remove (Node : Node_Or_Entity_Id);
    --  Removes Node, which must be a node that is a member of a node list,
    --  from this node list. The contents of Node are not otherwise affected.
 
-   function Remove_Head (List : List_Id) return Node_Id;
+   function Remove_Head (List : List_Id) return Node_Or_Entity_Id;
    --  Removes the head element of a node list, and returns the node (whose
    --  contents are not otherwise affected) as the result. If the node list
    --  is empty, then Empty is returned.
 
-   function Remove_Next (Node : Node_Id) return Node_Id;
+   function Remove_Next (Node : Node_Or_Entity_Id) return Node_Or_Entity_Id;
    --  Removes the item immediately following the given node, and returns it
    --  as the result. If Node is the last element of the list, then Empty is
    --  returned. Node must be a member of a list. Unlike Remove, Remove_Next
@@ -302,13 +333,13 @@ package Nlists is
    --  Writes out internal tables to current tree file using the relevant
    --  Table.Tree_Write routines.
 
-   function Parent (List : List_Id) return Node_Id;
+   function Parent (List : List_Id) return Node_Or_Entity_Id;
    pragma Inline (Parent);
    --  Node lists may have a parent in the same way as a node. The function
    --  accesses the Parent value, which is either Empty when a list header
    --  is first created, or the value that has been set by Set_Parent.
 
-   procedure Set_Parent (List : List_Id; Node : Node_Id);
+   procedure Set_Parent (List : List_Id; Node : Node_Or_Entity_Id);
    pragma Inline (Set_Parent);
    --  Sets the parent field of the given list to reference the given node
 
@@ -322,7 +353,7 @@ package Nlists is
    --  Tests given Id for inequality with No_List. This allows notations like
    --  "if Present (Statements)" as opposed to "if Statements /= No_List".
 
-   procedure Allocate_List_Tables (N : Node_Id);
+   procedure Allocate_List_Tables (N : Node_Or_Entity_Id);
    --  Called when nodes table is expanded to include node N. This call
    --  makes sure that list structures internal to Nlists are adjusted
    --  appropriately to reflect this increase in the size of the nodes table.
@@ -332,7 +363,7 @@ package Nlists is
    --  These functions return the addresses of the Next_Node and Prev_Node
    --  tables (used in Back_End for Gigi).
 
-   function p (U : Union_Id) return Node_Id;
+   function p (U : Union_Id) return Node_Or_Entity_Id;
    --  This function is intended for use from the debugger, it determines
    --  whether U is a Node_Id or List_Id, and calls the appropriate Parent
    --  function and returns the parent Node in either case. This is shorter
Index: sem_ch6.adb
===================================================================
--- sem_ch6.adb	(revision 164055)
+++ sem_ch6.adb	(working copy)
@@ -1638,9 +1638,7 @@ package body Sem_Ch6 is
 
          if Present (Prag) then
             if Present (Spec_Id) then
-               if List_Containing (N) =
-                 List_Containing (Unit_Declaration_Node (Spec_Id))
-               then
+               if In_Same_List (N, Unit_Declaration_Node (Spec_Id)) then
                   Analyze (Prag);
                end if;
 
@@ -1649,10 +1647,12 @@ package body Sem_Ch6 is
 
                declare
                   Subp : constant Entity_Id :=
-                    Make_Defining_Identifier (Loc, Chars (Body_Id));
+                           Make_Defining_Identifier (Loc, Chars (Body_Id));
                   Decl : constant Node_Id :=
-                    Make_Subprogram_Declaration (Loc,
-                      Specification =>  New_Copy_Tree (Specification (N)));
+                           Make_Subprogram_Declaration (Loc,
+                             Specification =>
+                               New_Copy_Tree (Specification (N)));
+
                begin
                   Set_Defining_Unit_Name (Specification (Decl), Subp);
 
@@ -7993,9 +7993,7 @@ package body Sem_Ch6 is
                        ("equality operator must be declared "
                          & "before type& is frozen", S, Typ);
 
-                  elsif List_Containing (Parent (Typ))
-                          /=
-                        List_Containing (Decl)
+                  elsif not In_Same_List (Parent (Typ), Decl)
                     and then not Is_Limited_Type (Typ)
                   then
                      Error_Msg_N
