[cfe-commits] RFC: C++ References Patch

[Chris Lattner]

On Nov 27, 2007, at 2:12 AM, Bill Wendling wrote:
> This is a long awaited patch for the failure in cxx-references.cpp.
> The idea is that during the typesAreCompatible method, it should
> ignore any references, according to the section [expr] in the C++
> standard (quoted in the comment below). At this point, we basically
> have a "pointer to a reference" coming into this method. This is
> because of how the code is parsed -- the variable is a reference, and
> its address is taken. Note, however, that a pointer to a reference is
> invalid C++ code. I suppose that we'd ideally like to have it never
> be a pointer to a reference. That is to have the reference part of
> the type removed before the pointer type to that type is created. I'm
> not sure how much information this would lose doing that though.
>
> Because it removes the reference, there's no longer a need to have
> the Type::Reference in the switch statement.

This patch looks great, please commit.  In the future, please attach  
patches instead of including them inline.  Mailers often wrap patches,  
which makes them hard to read and impossible to apply.

Thanks!

-Chris

>
> Comments?
>
> -bw
>
> Index: test/Sema/cxx-references.cpp
> ===================================================================
> --- test/Sema/cxx-references.cpp        (revision 44358)
> +++ test/Sema/cxx-references.cpp        (working copy)
> @@ -5,9 +5,7 @@
>    int i;
>    int &r = i;
>    r = 1;
> -#if 0  // FIXME: &ref not right yet
>    int *p = &r;
> -#endif
>    int &rr = r;
>    int (&rg)(int) = g;
>    rg(i);
> Index: AST/ASTContext.cpp
> ===================================================================
> --- AST/ASTContext.cpp  (revision 44358)
> +++ AST/ASTContext.cpp  (working copy)
> @@ -1217,7 +1217,7 @@
>    return typesAreCompatible(ltype, rtype);
>  }
>
> -// C++ 5.17p6: When the left opperand of an assignment operator
> denotes a
> +// C++ 5.17p6: When the left operand of an assignment operator
> denotes a
>  // reference to T, the operation assigns to the object of type T
> denoted by the
>  // reference.
>  bool ASTContext::referenceTypesAreCompatible(QualType lhs, QualType
> rhs) {
> @@ -1299,6 +1299,15 @@
>    // If two types are identical, they are are compatible
>    if (lcanon == rcanon)
>      return true;
> +
> +  // C++ [expr]: If an expression initially has the type "reference
> to T", the
> +  // type is adjusted to "T" prior to any further analysis, the
> expression
> +  // designates the object or function denoted by the reference, and
> the
> +  // expression is an lvalue.
> +  if (lcanon->getTypeClass() == Type::Reference)
> +    lcanon = cast<ReferenceType>(lcanon)->getReferenceeType();
> +  if (rcanon->getTypeClass() == Type::Reference)
> +    rcanon = cast<ReferenceType>(rcanon)->getReferenceeType();
>
>    // If the canonical type classes don't match, they can't be
> compatible
>    if (lcanon->getTypeClass() != rcanon->getTypeClass()) {
> @@ -1312,8 +1321,6 @@
>    switch (lcanon->getTypeClass()) {
>      case Type::Pointer:
>        return pointerTypesAreCompatible(lcanon, rcanon);
> -    case Type::Reference:
> -      return referenceTypesAreCompatible(lcanon, rcanon);
>      case Type::ConstantArray:
>      case Type::VariableArray:
>        return arrayTypesAreCompatible(lcanon, rcanon);
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits