basic.lookup.general

Author: jensmaurer

source/basic.tex

@@ -1336,9 +1336,10 @@
 
 \rSec1[basic.lookup]{Name lookup}%
 
+\indextext{lookup!name|(}
+
 \rSec2[basic.lookup.general]{General}%
-\indextext{scope!name lookup and|(}%
-\indextext{lookup!name|(}%
+\indextext{scope!name lookup and|see{lookup, name}}%
 
 \pnum
 The name lookup rules apply uniformly to all names (including
@@ -1348,36 +1349,98 @@
 such names in the context discussed by a particular rule. Name lookup
 associates the use of a name with a set of declarations\iref{basic.def} of
 that name.
+Unless otherwise specified,
+the program is ill-formed if no declarations are found.
 If the declarations found by name lookup
 all denote functions or function templates,
 the declarations are said to form an \defn{overload set}.
-The declarations found by name lookup shall either
-all denote the same entity or form an overload set.
+Otherwise,
+if the declarations found by name lookup do not all denote the same entity,
+they are \defn{ambiguous} and the program is ill-formed.
 Overload resolution~(\ref{over.match}, \ref{over.over})
 takes place after name lookup has succeeded. The access rules\iref{class.access}
 are considered only once name lookup and
 function overload resolution (if applicable) have succeeded. Only after
 name lookup, function overload resolution (if applicable) and access
 checking have succeeded
-are the semantic properties introduced by the name's declaration
-and its reachable\iref{module.reach} redeclarations
-used further in expression processing\iref{expr}.
+are the semantic properties introduced by the declarations
+used in further processing.
 
 \pnum
-A name ``looked up in the context of an expression'' is looked up
-in the scope where the expression is found.
+A program point $P$ is said to follow
+any declaration in the same translation unit
+whose locus\iref{basic.scope.pdecl} is before $P$.
+\begin{note}
+The declaration might appear in a scope that does not contain $P$.
+\end{note}
+A declaration $X$ \defnx{precedes}{precede}
+a program point $P$ in a translation unit $L$
+if $P$ follows $X$, $X$ inhabits a class scope and is reachable from $P$, or
+else $X$ appears in a translation unit $D$ and
+\begin{itemize}
+\item
+$P$ follows
+a \grammarterm{module-import-declaration} or \grammarterm{module-declaration}
+that imports $D$ (directly or indirectly), and
+\item
+$X$ appears after the \grammarterm{module-declaration} in $D$ (if any) and
+before the \grammarterm{private-module-fragment} in $D$ (if any), and
+\item
+either $X$ is exported or else $D$ and $L$ are part of the same module and
+$X$ does not inhabit a namespace with internal linkage or
+declare a name with internal linkage.
+\begin{note}
+Names declared by a \grammarterm{using-declaration} have no linkage.
+\end{note}
+\end{itemize}
+\begin{note}
+A \grammarterm{module-import-declaration} imports both
+the named translation unit(s) and
+any modules named by exported
+\grammarterm{module-import-declaration}{s} within them,
+recursively.
+\begin{example}
+\begin{codeblocktu}{Translation unit \#1}
+export module Q;
+export int sq(int i) { return i*i; }
+\end{codeblocktu}
+
+\begin{codeblocktu}{Translation unit \#2}
+export module R;
+export import Q;
+\end{codeblocktu}
+
+\begin{codeblocktu}{Translation unit \#3}
+import R;
+int main() { return sq(9); }    // OK: \tcode{sq} from module \tcode{Q}
+\end{codeblocktu}
+\end{example}
+\end{note}
 
 \pnum
-The injected-class-name of a class\iref{class.pre} is also
-considered to be a member of that class for the purposes of name hiding
-and lookup.
+A \defnadj{single}{search} in a scope $S$
+for a name $N$ from a program point $P$
+finds all declarations that precede $P$
+to which any name that is the same as $N$\iref{basic.pre} is bound in $S$.
+If any such declaration is a \grammarterm{using-declarator}
+whose terminal name\iref{expr.prim.id.unqual}
+is not dependent\iref{temp.dep.type},
+it is replaced by the declarations named by
+the \grammarterm{using-declarator}\iref{namespace.udecl}.
 
 \pnum
+In certain contexts, only certain kinds of declarations are included.
+After any such restriction, any declarations of classes or enumerations are discarded if any other declarations are found.
 \begin{note}
-\ref{basic.link} discusses linkage issues. The notions of
-scope, point of declaration and name hiding are discussed
-in~\ref{basic.scope}.
+A type (but not a \grammarterm{typedef-name} or template)
+is therefore hidden by any other entity in its scope.
 \end{note}
+However, if a lookup is type-only, only declarations of types and
+templates whose specializations are types are considered;
+furthermore, if declarations
+of a \grammarterm{typedef-name} and of the type to which it refers are found,
+the declaration of the \grammarterm{typedef-name} is discarded
+instead of the type declaration.
 
 \rSec2[basic.lookup.unqual]{Unqualified name lookup}
 
@@ -2593,7 +2656,6 @@
 \grammarterm{nested-name-specifier}{}
 only namespace names are considered.%
 \indextext{lookup!name|)}%
-\indextext{scope!name lookup and|)}
 
 \rSec1[basic.link]{Program and linkage}%
 \indextext{linkage|(}