On 10 Nov 2006 19:15:45 +0100, Gabriel Dos Reis
<[EMAIL PROTECTED]> wrote:
"Doug Gregor" <[EMAIL PROTECTED]> writes:
| With concepts, there are cases where we end up creating two different
| type nodes that we later find out should have been the same type node.
| Here's an example:
|
|   template<typename T, typename U>
|   where LessThanComparable<T> && SameType<T, U>
|   const T& weird_min(const T& t, const U& u) {
|     return t < u? t : u;
|   }
|
| When we parse the template header, we create two different type nodes
| for T and U. Then we start parsing the where clause, and create a type
| node for LessThanComparable<T>. Now we hit the SameType requirement,
| which says that T and U are the same type. It's a little late to make
| T and U actually have the same type node (unless we want to re-parse
| the template or re-write the AST).

I don't think that implies rewriting the AST or reparsing.  The
same-type constraints reads to me that "it is assume T and U have the
same canonical type", e.g. the predicate SameType<T, U> translates to
the constraints

     TYPE_CANONICAL(T) == TYPE_CANONICAL(U)

this equation can be added the constraint set without reparsing (it is
a semantic constraint).

Yes, but there are types built from 'T' and 'U' that also need to be
"merged" in this way. For instance, say we have built the types T* and
U* before seeing that same-type constraint. Now, we also need
TYPE_CANONICAL (T*) == TYPE_CANONICAL (U*).
And TYPE_CANONICAL(LessThanComparable<T>) ==
TYPE_CANONICAL(LessThanComparable<U>).
If you know about all of these other types that have been built from T
and U, you can use Nelson and Oppen's algorithm to update the
TYPE_CANONICAL information relatively quickly. If you don't have that
information... you're stuck with structural checks or rewriting the
AST to eliminate the duplicated nodes.

 Cheers,
 Doug

Reply via email to