blob: 018c2837fd7e0a8d1cbc4be8355921e5df9448b1 [file] [log] [blame]
-- --
-- --
-- S E M _ T Y P E --
-- --
-- S p e c --
-- --
-- Copyright (C) 1992-2021, 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- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
-- for more details. You should have received a copy of the GNU General --
-- Public License distributed with GNAT; see file COPYING3. If not, go to --
-- for a complete copy of the license. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
-- This unit contains the routines used to handle type determination,
-- including the routine used to support overload resolution.
with Types; use Types;
package Sem_Type is
-- Data Structures for Overload Resolution --
-- To determine the unique meaning of an identifier, overload resolution
-- may have to be performed if the visibility rules alone identify more
-- than one possible entity as the denotation of a given identifier. When
-- the visibility rules find such a potential ambiguity, the set of
-- possible interpretations must be attached to the identifier, and
-- overload resolution must be performed over the innermost enclosing
-- complete context. At the end of the resolution, either a single
-- interpretation is found for all identifiers in the context, or else a
-- type error (invalid type or ambiguous reference) must be signalled.
-- The set of interpretations of a given name is stored in a data structure
-- that is separate from the syntax tree, because it corresponds to
-- transient information. The interpretations themselves are stored in
-- table All_Interp. A mapping from tree nodes to sets of interpretations
-- called Interp_Map, is maintained by the overload resolution routines.
-- Both these structures are initialized at the beginning of every complete
-- context.
-- Corresponding to the set of interpretations for a given overloadable
-- identifier, there is a set of possible types corresponding to the types
-- that the overloaded call may return. We keep a 1-to-1 correspondence
-- between interpretations and types: for user-defined subprograms the type
-- is the declared return type. For operators, the type is determined by
-- the type of the arguments. If the arguments themselves are overloaded,
-- we enter the operator name in the names table for each possible result
-- type. In most cases, arguments are not overloaded and only one
-- interpretation is present anyway.
type Interp is record
Nam : Entity_Id;
Typ : Entity_Id;
Abstract_Op : Entity_Id := Empty;
end record;
-- Entity Abstract_Op is set to the abstract operation which potentially
-- disables the interpretation in Ada 2005 mode.
No_Interp : constant Interp := (Empty, Empty, Empty);
type Interp_Index is new Int;
-- Error Reporting --
-- A common error is the use of an operator in infix notation on arguments
-- of a type that is not directly visible. Rather than diagnosing a type
-- mismatch, it is better to indicate that the type can be made use-visible
-- with the appropriate use clause. The global variable Candidate_Type is
-- set in Add_One_Interp whenever an interpretation might be legal for an
-- operator if the type were directly visible. This variable is used in
-- Sem_Ch4 when no legal interpretation is found.
Candidate_Type : Entity_Id;
-- Subprograms --
procedure Init_Interp_Tables;
-- Initialize data structures for overload resolution
procedure Collect_Interps (N : Node_Id);
-- Invoked when the name N has more than one visible interpretation. This
-- is the high level routine which accumulates the possible interpretations
-- of the node. The first meaning and type of N have already been stored
-- in N. If the name is an expanded name, the homonyms are only those that
-- belong to the same scope.
function Is_Invisible_Operator (N : Node_Id; T : Entity_Id) return Boolean;
-- Check whether a predefined operation with universal operands appears in
-- a context in which the operators of the expected type are not visible.
procedure List_Interps (Nam : Node_Id; Err : Node_Id);
-- List candidate interpretations of an overloaded name. Used for various
-- error reports.
procedure Add_One_Interp
(N : Node_Id;
E : Entity_Id;
T : Entity_Id;
Opnd_Type : Entity_Id := Empty);
-- Add (E, T) to the list of interpretations of the node being resolved.
-- For calls and operators, i.e. for nodes that have a name field, E is an
-- overloadable entity, and T is its type. For constructs such as indexed
-- expressions, the caller sets E equal to T, because the overloading comes
-- from other fields, and the node itself has no name to resolve. Hidden
-- denotes whether an interpretation has been disabled by an abstract
-- operator. Add_One_Interp includes semantic processing to deal with
-- adding entries that hide one another etc.
-- For operators, the legality of the operation depends on the visibility
-- of T and its scope. If the operator is an equality or comparison, T is
-- always Boolean, and we use Opnd_Type, which is a candidate type for one
-- of the operands of N, to check visibility.
procedure Get_First_Interp
(N : Node_Id;
I : out Interp_Index;
It : out Interp);
-- Initialize iteration over set of interpretations for Node N. The first
-- interpretation is placed in It, and I is initialized for subsequent
-- calls to Get_Next_Interp.
procedure Get_Next_Interp (I : in out Interp_Index; It : out Interp);
-- Iteration step over set of interpretations. Using the value in I, which
-- was set by a previous call to Get_First_Interp or Get_Next_Interp, the
-- next interpretation is placed in It, and I is updated for the next call.
-- The end of the list of interpretations is signalled by It.Nam = Empty.
procedure Remove_Interp (I : in out Interp_Index);
-- Remove an interpretation that is hidden by another, or that does not
-- match the context. The value of I on input was set by a call to either
-- Get_First_Interp or Get_Next_Interp and references the interpretation
-- to be removed. The only allowed use of the exit value of I is as input
-- to a subsequent call to Get_Next_Interp, which yields the interpretation
-- following the removed one.
procedure Save_Interps (Old_N : Node_Id; New_N : Node_Id);
-- If an overloaded node is rewritten during semantic analysis, its
-- possible interpretations must be linked to the copy. This procedure
-- transfers the overload information (Is_Overloaded flag, and list of
-- interpretations) from Old_N, the old node, to New_N, its new copy.
-- It has no effect in the non-overloaded case.
function Covers (T1, T2 : Entity_Id) return Boolean;
-- This is the basic type compatibility routine. T1 is the expected type,
-- imposed by context, and T2 is the actual type. The processing reflects
-- both the definition of type coverage and the rules for operand matching;
-- that is, this does not exactly match the RM definition of "covers".
function Disambiguate
(N : Node_Id;
I1, I2 : Interp_Index;
Typ : Entity_Id) return Interp;
-- If more than one interpretation of a name in a call is legal, apply
-- preference rules (universal types first) and operator visibility in
-- order to remove ambiguity. I1 and I2 are the first two interpretations
-- that are compatible with the context, but there may be others.
function Entity_Matches_Spec (Old_S, New_S : Entity_Id) return Boolean;
-- To resolve subprogram renaming and default formal subprograms in generic
-- definitions. Old_S is a possible interpretation of the entity being
-- renamed, New_S has an explicit signature. If Old_S is a subprogram, as
-- opposed to an operator, type and mode conformance are required.
function Find_Unique_Type (L : Node_Id; R : Node_Id) return Entity_Id;
-- Used in second pass of resolution, for equality and comparison nodes. L
-- is the left operand, whose type is known to be correct, and R is the
-- right operand, which has one interpretation compatible with that of L.
-- Return the type intersection of the two.
function Has_Compatible_Type (N : Node_Id; Typ : Entity_Id) return Boolean;
-- Verify that some interpretation of the node N has a type compatible with
-- Typ. If N is not overloaded, then its unique type must be compatible
-- with Typ. Otherwise iterate through the interpretations of N looking for
-- a compatible one.
function Hides_Op (F : Entity_Id; Op : Entity_Id) return Boolean;
-- A user-defined function hides a predefined operator if it matches the
-- signature of the operator, and is declared in an open scope, or in the
-- scope of the result type.
function Interface_Present_In_Ancestor
(Typ : Entity_Id;
Iface : Entity_Id) return Boolean;
-- Ada 2005 (AI-251): Typ must be a tagged record type/subtype and Iface
-- must be an abstract interface type (or a class-wide abstract interface).
-- This function is used to check if Typ or some ancestor of Typ implements
-- Iface (returning True only if so).
function Intersect_Types (L, R : Node_Id) return Entity_Id;
-- Find the common interpretation to two analyzed nodes. If one of the
-- interpretations is universal, choose the non-universal one. If either
-- node is overloaded, find single common interpretation.
function In_Generic_Actual (Exp : Node_Id) return Boolean;
-- Determine whether the expression is part of a generic actual. At the
-- time the actual is resolved the scope is already that of the instance,
-- but conceptually the resolution of the actual takes place in the
-- enclosing context and no special disambiguation rules should be applied.
function Is_Ancestor
(T1 : Entity_Id;
T2 : Entity_Id;
Use_Full_View : Boolean := False) return Boolean;
-- T1 is a tagged type (not class-wide). Verify that it is one of the
-- ancestors of type T2 (which may or not be class-wide). If Use_Full_View
-- is True then the full-view of private parents is used when climbing
-- through the parents of T2.
-- Note: For analysis purposes the flag Use_Full_View must be set to False
-- (otherwise we break the privacy contract since this routine returns true
-- for hidden ancestors of private types). For expansion purposes this flag
-- is generally set to True since the expander must know with precision the
-- ancestors of a tagged type. For example, if a private type derives from
-- an interface type then the interface may not be an ancestor of its full
-- view since the full-view is only required to cover the interface (RM 7.3
-- (7.3/2))) and this knowledge affects construction of dispatch tables.
function Is_Progenitor
(Iface : Entity_Id;
Typ : Entity_Id) return Boolean;
-- Determine whether the interface Iface is implemented by Typ. It requires
-- traversing the list of abstract interfaces of the type, as well as that
-- of the ancestor types. The predicate is used to determine when a formal
-- in the signature of an inherited operation must carry the derived type.
function Is_Subtype_Of (T1 : Entity_Id; T2 : Entity_Id) return Boolean;
-- Checks whether T1 is any subtype of T2 directly or indirectly
function Operator_Matches_Spec (Op, New_S : Entity_Id) return Boolean;
-- Used to resolve subprograms renaming operators, and calls to user
-- defined operators. Determines whether a given operator Op, matches
-- a specification, New_S.
procedure Set_Abstract_Op (I : Interp_Index; V : Entity_Id);
-- Set the abstract operation field of an interpretation
function Valid_Comparison_Arg (T : Entity_Id) return Boolean;
-- A valid argument to an ordering operator must be a discrete type, a
-- real type, or a one dimensional array with a discrete component type.
function Valid_Boolean_Arg (T : Entity_Id) return Boolean;
-- A valid argument of a boolean operator is either some boolean type, or a
-- one-dimensional array of boolean type.
procedure Write_Interp (It : Interp);
-- Debugging procedure to display an Interp
procedure Write_Overloads (N : Node_Id);
-- Debugging procedure to output info on possibly overloaded entities for
-- specified node.
end Sem_Type;