[Sema] When dereferencing a pointer of dependent type, infer the result type.

[courbet]

Summary

Example:

template <typename T> auto f(T* t) {
  return *t;
}

Before that change, the UnaryOperator for *t has type <dependent type>.
After the change, its type is a T lvalue.

I've added simple tests to verify that giving knowledge of the type to clang
does not yields false positives in contexts where c++ does not allow it to use
that knowledge.

[courbet]

As per the comment in BuiltinTypes.def (see below), Dependent is
allowed in context where the type is deducible, but is there any reason
not to deduce the type if we can do it cheaply in some cases ?

// This represents the type of an expression whose type is
// totally unknown, e.g. 'T::foo'.  It is permitted for this to
// appear in situations where the structure of the type is
// theoretically deducible.
BUILTIN_TYPE(Dependent, DependentTy)

[courbet]

Ping ?

[aaron.ballman]

In D112453#3084394, @courbet wrote:

As per the comment in BuiltinTypes.def (see below), Dependent is
allowed in context where the type is deducible, but is there any reason
not to deduce the type if we can do it cheaply in some cases ?

// This represents the type of an expression whose type is
// totally unknown, e.g. 'T::foo'.  It is permitted for this to
// appear in situations where the structure of the type is
// theoretically deducible.
BUILTIN_TYPE(Dependent, DependentTy)

I've been trying to think if this will cause problems or not, and I'm not convinced one way or the other. I was thinking that if we resolve the type to a non-dependent type, but it is used within another type (making the second type also dependent), won't we change the point of instantiation for that second dependent type?

[rsmith]

I think the idea of this change is OK. The key is that the dereference expression will still be type-dependent, even if we happen to actually know its type. (For an Expr that isTypeDependent(), the type produced by getType() isn't something the standard knows or cares about and is only used for our own type-checking-of-templates purposes.) The property we need to guarantee is that, if the Expr is valid, then the type is correct, and I think that holds here. However, I wouldn't want to guarantee that all parts of Clang get this right, and we might find some lurking bugs are exposed by this change.

I think this change is being made in an imperfect place, though. Instead of putting a special case in here, how would we feel about making Type::isOverloadableType() smarter, to return false for dependent types that can't possibly be class or enum types (eg, dependent pointer types, array types, and maybe more exotic things like function types, atomic types, and complex types)? This would then apply to all operators, not only unary *. Eg, we know the type of &p where p is T*, and we know the type of p + n where p is T* and n is integral. That change might have a lot more fallout, but it'd certainly be interesting to see what it breaks.

Is this change observable in some way? We should include a test with this change that demonstrates what effect it has. (The existing test in this patch passes with or without the change.) If nothing else I think we should be able to see the effect of this change in the output of -ast-dump. (Making the more general change I mentioned above may help here, by giving earlier diagnostics for some cases for which instantiation could never succeed, such as rejecting p + q where p and q are both pointer types.)

[courbet]

In D112453#3103515, @rsmith wrote:

I think this change is being made in an imperfect place, though. Instead of putting a special case in here, how would we feel about making Type::isOverloadableType() smarter, to return false for dependent types that can't possibly be class or enum types (eg, dependent pointer types, array types, and maybe more exotic things like function types, atomic types, and complex types)? This would then apply to all operators, not only unary *. Eg, we know the type of &p where p is T*, and we know the type of p + n where p is T* and n is integral. That change might have a lot more fallout, but it'd certainly be interesting to see what it breaks.

Thanks for the suggestion ! I've improved test coverage for unary operators in rG1427742750ed. There was a minor breakage with this change in Sema::DefaultLvalueConversion which did not handle dependant pointers.

Binary operators look like they break more things. Working on it now.

Is this change observable in some way? We should include a test with this change that demonstrates what effect it has. (The existing test in this patch passes with or without the change.)

Yes, I agree. The idea of this test was just to check that adding this did not have side effects on how clang was handling what the standard mandates, but you've covered this in the first part of your answer, thanks.
I don't think it's observable directly (I'm observing the type using getType() directly in my case), so I'll add an AST dump test, thanks for the suggestion.

[courbet]

Implement the proposed changes.

[courbet]

Is this change observable in some way?

With the new changes, we are now catching more typing errors before instantiation. I've added more tests to show that.

[courbet]

one more spaceship operator fix.

[courbet]

ping

[courbet]

ping

[aaron.ballman]

clang/lib/Sema/SemaExpr.cpp

10547–10549

13827–13828

One thing that makes me a bit uncomfortable is that the logic for these used to be far more understandable when it was just checking for a dependent type. Now we need to sprinkle "and not a pointer type" in places, but it's not particularly clear as to why for a naïve reader of the code.

I wonder if we want some sort of type predicate isDeferrablyDependentType() or something along those lines, or whether that's not really plausible? Basically, I'm hoping to find a way that, as a code reviewer, I can more easily spot places where isTypeDependent() should really be caring about type dependent pointers as a special case.

[courbet]

Try to get rid of "dependent and not a pointer" checks checks.

clang/lib/Sema/SemaExpr.cpp

13827–13828

Right, so in this function Op->isTypeDependent() is always used to bail out from type checking. The structure is typically:

if (E->isTypeDependent()) {
  // bail out
}
// Actual type checking on provable types.
if (E->hasSomeTypeProperty1()) {
  // OK case, do some property1-specific checking
} else if (E->hasSomeTypeProperty2()) {
  // OK case, do some property2-specific checking
} else {
  // Emit some error
}

My original approach was to do:

if (E->isTypeDependent() && !E->isPointerType()) {
  // bail out
}
// Actual type checking on provable types or pointer types.
if (E->hasSomeTypeProperty1()) {
  // OK case, do some property1-specific checking
} else if (E->hasSomeTypeProperty2()) {
  // OK case, do some property2-specific checking
} else {
  // Emit some error
}

It turns out that in all cases, hasSomeTypeProperty1 is actually isPointerType (or stuff like isScalarType, which includes pointers), so the current code is actually already checking for pointerness, so in a sense my new pointer type cheking is already included in subsequent checks, I'm not adding anything new.

But maybe another change like this one will be able to prove more stuff about dependent types (e.g. a dependent type could have propery2 too ), so what about we only bail out on dependent types *after* we are done with the type checking:

if (E->isTypeDependent() && !E->isPointerType()) {
  // bail out
}
// Actual type checking on provable types or pointer types.
if (E->hasSomeTypeProperty1()) {
  // OK case, do some property1-specific checking
} else if (E->hasSomeTypeProperty2()) {
  // OK case, do some property2-specific checking
} else if (if (E->isTypeDependent()) {
  // bail out
} else {
  // Emit some error
}

This essentially goes from "If the type is not dependent, try to prove stuff about the type, else return error" to "try to prove stuff about the type, else if not dependent, return error".

I'm modified the code here to use this approach, what do you think ?

clang/include/clang/AST/Type.h

 inline bool Type::isUndeducedType() const {
   auto *DT = getContainedDeducedType();
   return DT && !DT->isDeduced();
 }
 
 /// Determines whether this is a type for which one can define
 /// an overloaded operator.
 inline bool Type::isOverloadableType() const {
+  // (16.5.6): An operator function [...] parameter whose type is a class,
+  // a reference to a class, an enumeration, or a reference to an
+  // enumeration.
+  if (isPointerType()) {
+    // If the type is a pointer, it cannot be overloaded.
+    return false;
+  }
   return isDependentType() || isRecordType() || isEnumeralType();
 }
 
 /// Determines whether this type is written as a typedef-name.
 inline bool Type::isTypedefNameType() const {
   if (getAs<TypedefType>())
     return true;
   if (auto *TST = getAs<TemplateSpecializationType>())

clang/lib/Sema/SemaExpr.cpp

 //===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements semantic analysis for expressions.
ExprResult Sema::DefaultLvalueConversion(Expr *E) {
   // lvalue-to-rvalue conversion cannot be applied to function or array types.
   if (T->isFunctionType() || T->isArrayType())
     return E;
 
   // We don't want to throw lvalue-to-rvalue casts on top of
   // expressions of certain types in C++.
   if (getLangOpts().CPlusPlus &&
       (E->getType() == Context.OverloadTy ||
-       T->isDependentType() ||
-       T->isRecordType()))
+       (T->isDependentType() && !T->isPointerType()) || T->isRecordType()))
     return E;
 
   // The C standard is actually really unclear on this point, and
   // DR106 tells us what the result should be but not why.  It's
   // generally best to say that void types just doesn't undergo
   // lvalue-to-rvalue at all.  Note that expressions of unqualified
   // 'void' type are never l-values, but qualified void can be.
   if (T->isVoidType())
static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc,
                                             Expr *Operand) {
   QualType ResType = Operand->getType();
   if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
     ResType = ResAtomicType->getValueType();
 
   if (!ResType->isAnyPointerType()) return true;
 
   QualType PointeeTy = ResType->getPointeeType();
+  if (PointeeTy->isDependentType())
+    return true;
   if (PointeeTy->isVoidType()) {
     diagnoseArithmeticOnVoidPointer(S, Loc, Operand);
     return !S.getLangOpts().CPlusPlus;
   }
   if (PointeeTy->isFunctionType()) {
     diagnoseArithmeticOnFunctionPointer(S, Loc, Operand);
     return !S.getLangOpts().CPlusPlus;
   }
 
if (isLHSFuncPtr || isRHSFuncPtr) {
     if (!isRHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, LHSExpr);
     else if (!isLHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc,
                                                                 RHSExpr);
     else diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHSExpr, RHSExpr);
 
     return !S.getLangOpts().CPlusPlus;
   }
 
-  if (isLHSPointer && checkArithmeticIncompletePointerType(S, Loc, LHSExpr))
+  if (isLHSPointer && !LHSPointeeTy->isDependentType() &&
+      checkArithmeticIncompletePointerType(S, Loc, LHSExpr))
     return false;
-  if (isRHSPointer && checkArithmeticIncompletePointerType(S, Loc, RHSExpr))
+  if (isRHSPointer && !RHSPointeeTy->isDependentType() &&
+      checkArithmeticIncompletePointerType(S, Loc, RHSExpr))
     return false;
 
   return true;
 }
 
 /// diagnoseStringPlusInt - Emit a warning when adding an integer to a string
 /// literal.
 static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc,
if (LHS.get()->getType()->isAnyPointerType()) {
 
     // Handle pointer-pointer subtractions.
     if (const PointerType *RHSPTy
           = RHS.get()->getType()->getAs<PointerType>()) {
       QualType rpointee = RHSPTy->getPointeeType();
 
       if (getLangOpts().CPlusPlus) {
         // Pointee types must be the same: C++ [expr.add]
-        if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) {
+        // If pointees are dependent types, we defer this to later.
+        if (!lpointee->isDependentType() && !rpointee->isDependentType() &&
+            !Context.hasSameUnqualifiedType(lpointee, rpointee)) {
           diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get());
         }
       } else {
         // Pointee types must be compatible C99 6.5.6p3
         if (!Context.typesAreCompatible(
                 Context.getCanonicalType(lpointee).getUnqualifiedType(),
                 Context.getCanonicalType(rpointee).getUnqualifiedType())) {
           diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get());
if (const PointerType *RHSPTy
       if (LHSIsNullPtr)
         diagnoseSubtractionOnNullPointer(*this, Loc, LHS.get(), RHSIsNullPtr);
       if (RHSIsNullPtr)
         diagnoseSubtractionOnNullPointer(*this, Loc, RHS.get(), LHSIsNullPtr);
 
       // The pointee type may have zero size.  As an extension, a structure or
       // union may have zero size or an array may have zero length.  In this
       // case subtraction does not make sense.
-      if (!rpointee->isVoidType() && !rpointee->isFunctionType()) {
+      if (!rpointee->isDependentType() && !rpointee->isVoidType() &&
+          !rpointee->isFunctionType()) {
         CharUnits ElementSize = Context.getTypeSizeInChars(rpointee);
         if (ElementSize.isZero()) {
           Diag(Loc,diag::warn_sub_ptr_zero_size_types)
             << rpointee.getUnqualifiedType()
             << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
         }
       }
 
QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
   const Expr::NullPointerConstantKind RHSNullKind =
       RHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull);
   bool LHSIsNull = LHSNullKind != Expr::NPCK_NotNull;
   bool RHSIsNull = RHSNullKind != Expr::NPCK_NotNull;
 
   auto computeResultTy = [&]() {
     if (Opc != BO_Cmp)
       return Context.getLogicalOperationType();
+    if (LHS.get()->getType()->isDependentType() ||
+        RHS.get()->getType()->isDependentType())
+      return QualType(Context.DependentTy);
     assert(getLangOpts().CPlusPlus);
     assert(Context.hasSameType(LHS.get()->getType(), RHS.get()->getType()));
 
     QualType CompositeTy = LHS.get()->getType();
     assert(!CompositeTy->isReferenceType());
 
     Optional<ComparisonCategoryType> CCT =
         getComparisonCategoryForBuiltinCmp(CompositeTy);

 
 /// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine
 /// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions.
 static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op,
                                                ExprValueKind &VK,
                                                ExprObjectKind &OK,
                                                SourceLocation OpLoc,
                                                bool IsInc, bool IsPrefix) {
-  if (Op->isTypeDependent())
+  if (Op->isTypeDependent() && !Op->getType()->isPointerType())
     return S.Context.DependentTy;
 
   QualType ResType = Op->getType();
   // Atomic types can be used for increment / decrement where the non-atomic
   // versions can, so ignore the _Atomic() specifier for the purpose of
   // checking.
   if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
     ResType = ResAtomicType->getValueType();
if (!FD->hasAttr<NonNullAttr>() && !Param->hasAttr<NonNullAttr>())
       return;
   if (FunctionScopeInfo *FD = S.getCurFunction())
     if (!FD->ModifiedNonNullParams.count(Param))
       FD->ModifiedNonNullParams.insert(Param);
 }
 
 /// CheckIndirectionOperand - Type check unary indirection (prefix '*').
 static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
                                         SourceLocation OpLoc) {
-  if (Op->isTypeDependent())
-    return S.Context.DependentTy;
-
   ExprResult ConvResult = S.UsualUnaryConversions(Op);
   if (ConvResult.isInvalid())
     return QualType();
   Op = ConvResult.get();
   QualType OpTy = Op->getType();
   QualType Result;
 
   if (isa<CXXReinterpretCastExpr>(Op)) {
     QualType OpOrigType = Op->IgnoreParenCasts()->getType();
     S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/true,
                                      Op->getSourceRange());
   }
 
-  if (const PointerType *PT = OpTy->getAs<PointerType>())
-  {
+  if (const PointerType *PT = OpTy->getAs<PointerType>()) {
     Result = PT->getPointeeType();
-  }
-  else if (const ObjCObjectPointerType *OPT =
-             OpTy->getAs<ObjCObjectPointerType>())
+  } else if (const ObjCObjectPointerType *OPT =
+             OpTy->getAs<ObjCObjectPointerType>()) {
     Result = OPT->getPointeeType();
-  else {
+  } else if (Op->isTypeDependent()) {
+    return S.Context.DependentTy;
+  } else {
     ExprResult PR = S.CheckPlaceholderExpr(Op);
     if (PR.isInvalid()) return QualType();
     if (PR.get() != Op)
       return CheckIndirectionOperand(S, PR.get(), VK, OpLoc);
   }
 
   if (Result.isNull()) {
     S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
if (getLangOpts().OpenCL) {
     }
   }
 
   checkTypeSupport(LHSExpr->getType(), OpLoc, /*ValueDecl*/ nullptr);
   checkTypeSupport(RHSExpr->getType(), OpLoc, /*ValueDecl*/ nullptr);
 
   switch (Opc) {
   case BO_Assign:
+    if (getLangOpts().CPlusPlus &&
+        (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent()))
+      ResultTy = LHSExpr->getType();
+    else
       ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, QualType());
     if (getLangOpts().CPlusPlus &&
         LHS.get()->getObjectKind() != OK_ObjCProperty) {
       VK = LHS.get()->getValueKind();
       OK = LHS.get()->getObjectKind();
     }
     if (!ResultTy.isNull()) {
       DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc, true);
       DiagnoseSelfMove(LHS.get(), RHS.get(), OpLoc);
ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
   case BO_EQ:
   case BO_NE:
     ConvertHalfVec = true;
     ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc);
     break;
   case BO_Cmp:
     ConvertHalfVec = true;
     ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc);
-    assert(ResultTy.isNull() || ResultTy->getAsCXXRecordDecl());
+    assert(ResultTy.isNull() || ResultTy->isDependentType() ||
+           ResultTy->getAsCXXRecordDecl());
     break;
   case BO_And:
     checkObjCPointerIntrospection(*this, LHS, RHS, OpLoc);
     LLVM_FALLTHROUGH;
   case BO_Xor:
   case BO_Or:
     ResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc, Opc);
     break;
if (getLangOpts().CPlusPlus && pty->getKind() == BuiltinType::Overload &&
       return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
 
     ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr);
     if (!resolvedRHS.isUsable()) return ExprError();
     RHSExpr = resolvedRHS.get();
   }
 
   if (getLangOpts().CPlusPlus) {
-    // If either expression is type-dependent, always build an
-    // overloaded op.
-    if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent())
-      return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
-
-    // Otherwise, build an overloaded op if either expression has an
+    // Build an overloaded op if either expression has an
     // overloadable type.
     if (LHSExpr->getType()->isOverloadableType() ||
         RHSExpr->getType()->isOverloadableType())
       return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
   }
 
-  if (getLangOpts().RecoveryAST &&
+  if (!getLangOpts().CPlusPlus && getLangOpts().RecoveryAST &&
       (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent())) {
-    assert(!getLangOpts().CPlusPlus);
     assert((LHSExpr->containsErrors() || RHSExpr->containsErrors()) &&
            "Should only occur in error-recovery path.");
     if (BinaryOperator::isCompoundAssignmentOp(Opc))
       // C [6.15.16] p3:
       // An assignment expression has the value of the left operand after the
       // assignment, but is not an lvalue.
       return CompoundAssignOperator::Create(
           Context, LHSExpr, RHSExpr, Opc,
case UO_Minus:
     // do this only when HalfArgsAndReturns is set (that is, when the target is
     // arm or arm64).
     ConvertHalfVec = needsConversionOfHalfVec(true, Context, Input.get());
 
     // If the operand is a half vector, promote it to a float vector.
     if (ConvertHalfVec)
       Input = convertVector(Input.get(), Context.FloatTy, *this);
     resultType = Input.get()->getType();
-    if (resultType->isDependentType())
-      break;
     if (resultType->isArithmeticType()) // C99 6.5.3.3p1
       break;
     else if (resultType->isVectorType() &&
              // The z vector extensions don't allow + or - with bool vectors.
              (!Context.getLangOpts().ZVector ||
               resultType->castAs<VectorType>()->getVectorKind() !=
               VectorType::AltiVecBool))
       break;
     else if (getLangOpts().CPlusPlus && // C++ [expr.unary.op]p6
-             Opc == UO_Plus &&
-             resultType->isPointerType())
+             resultType->isPointerType()) {
+      if (Opc == UO_Plus)
+        break;
+    } else if (resultType->isDependentType())
       break;
 
     return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
       << resultType << Input.get()->getSourceRange());
 
   case UO_Not: // bitwise complement
     Input = UsualUnaryConversions(Input.get());
     if (Input.isInvalid())
       return ExprError();
     resultType = Input.get()->getType();
-    if (resultType->isDependentType())
-      break;
     // C99 6.5.3.3p1. We allow complex int and float as a GCC extension.
-    if (resultType->isComplexType() || resultType->isComplexIntegerType())
+    if (resultType->isComplexType() || resultType->isComplexIntegerType()) {
       // C99 does not support '~' for complex conjugation.
       Diag(OpLoc, diag::ext_integer_complement_complex)
           << resultType << Input.get()->getSourceRange();
-    else if (resultType->hasIntegerRepresentation())
       break;
-    else if (resultType->isExtVectorType() && Context.getLangOpts().OpenCL) {
+    } else if (resultType->hasIntegerRepresentation()) {
+      break;
+    } else if (resultType->isExtVectorType() && Context.getLangOpts().OpenCL) {
       // OpenCL v1.1 s6.3.f: The bitwise operator not (~) does not operate
       // on vector float types.
       QualType T = resultType->castAs<ExtVectorType>()->getElementType();
-      if (!T->isIntegerType())
-        return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
-                          << resultType << Input.get()->getSourceRange());
-    } else {
-      return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
+      if (T->isIntegerType())
+        break;
+    } else if (resultType->isPointerType()) {
+      // Bitwise complement of pointers is invalid.
+    } else if (resultType->isDependentType())
+      break;
                        << resultType << Input.get()->getSourceRange());
-    }
-    break;
 
   case UO_LNot: // logical negation
     // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5).
     Input = DefaultFunctionArrayLvalueConversion(Input.get());
     if (Input.isInvalid()) return ExprError();
     resultType = Input.get()->getType();
 
     // Though we still have to promote half FP to float...
     if (resultType->isHalfType() && !Context.getLangOpts().NativeHalfType) {
       Input = ImpCastExprToType(Input.get(), Context.FloatTy, CK_FloatingCast).get();
       resultType = Context.FloatTy;
     }
 
-    if (resultType->isDependentType())
-      break;
     if (resultType->isScalarType() && !isScopedEnumerationType(resultType)) {
       // C99 6.5.3.3p1: ok, fallthrough;
       if (Context.getLangOpts().CPlusPlus) {
         // C++03 [expr.unary.op]p8, C++0x [expr.unary.op]p9:
         // operand contextually converted to bool.
         Input = ImpCastExprToType(Input.get(), Context.BoolTy,
                                   ScalarTypeToBooleanCastKind(resultType));
       } else if (Context.getLangOpts().OpenCL &&
if (resultType->isScalarType() && !isScopedEnumerationType(resultType)) {
       const VectorType *VTy = resultType->castAs<VectorType>();
       if (VTy->getVectorKind() != VectorType::GenericVector)
         return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
                          << resultType << Input.get()->getSourceRange());
 
       // Vector logical not returns the signed variant of the operand type.
       resultType = GetSignedVectorType(resultType);
       break;
+    } else if (resultType->isDependentType()) {
+      break;
     } else {
       return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
         << resultType << Input.get()->getSourceRange());
     }
 
     // LNot always has type int. C99 6.5.3.3p5.
     // In C++, it's bool. C++ 5.3.1p8
     resultType = Context.getLogicalOperationType();

clang/lib/Sema/SemaExprCXX.cpp

QualType Sema::FindCompositePointerType(SourceLocation Loc,
   }
 
   // Now both have to be pointers or member pointers.
   if (!T1IsPointerLike || !T2IsPointerLike)
     return QualType();
   assert(!T1->isNullPtrType() && !T2->isNullPtrType() &&
          "nullptr_t should be a null pointer constant");
 
+  if (T1->getPointeeType()->isDependentType() ||
+      T2->getPointeeType()->isDependentType()) {
+    // We can't do the conversion now.
+    // FIXME: We know that the composite pointer type is a pointer type, return
+    // pointer to dependant type.
+    return Context.DependentTy;
+  }
+
   struct Step {
     enum Kind { Pointer, ObjCPointer, MemberPointer, Array } K;
     // Qualifiers to apply under the step kind.
     Qualifiers Quals;
     /// The class for a pointer-to-member; a constant array type with a bound
     /// (if any) for an array.
     const Type *ClassOrBound;
 

clang/test/AST/ast-dump-expr-json.cpp

 // CHECK-NEXT:                     },
 // CHECK-NEXT:                     "end": {
 // CHECK-NEXT:                      "offset": 1939,
 // CHECK-NEXT:                      "col": 8,
 // CHECK-NEXT:                      "tokLen": 1
 // CHECK-NEXT:                     }
 // CHECK-NEXT:                    },
 // CHECK-NEXT:                    "type": {
-// CHECK-NEXT:                     "qualType": "<dependent type>"
+// CHECK-NEXT:                     "qualType": "V"
 // CHECK-NEXT:                    },
-// CHECK-NEXT:                    "valueCategory": "prvalue",
+// CHECK-NEXT:                    "valueCategory": "lvalue",
 // CHECK-NEXT:                    "isPostfix": false,
 // CHECK-NEXT:                    "opcode": "*",
 // CHECK-NEXT:                    "canOverflow": false,
 // CHECK-NEXT:                    "inner": [
 // CHECK-NEXT:                     {
 // CHECK-NEXT:                      "id": "0x{{.*}}",
 // CHECK-NEXT:                      "kind": "CXXThisExpr",
 // CHECK-NEXT:                      "range": {

clang/test/AST/ast-dump-expr.cpp

void f() {
       // CHECK-NEXT: MoveConstructor
       // CHECK-NEXT: CopyAssignment
       // CHECK-NEXT: MoveAssignment
       // CHECK-NEXT: Destructor
       // CHECK-NEXT: CXXMethodDecl
       // CHECK-NEXT: CompoundStmt
       // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:8> col:8 implicit 'V'
       // CHECK-NEXT: ParenListExpr 0x{{[^ ]*}} <col:8> 'NULL TYPE'
-      // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:8> '<dependent type>' prefix '*' cannot overflow
+      // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:8> 'V' lvalue prefix '*' cannot overflow
       // CHECK-NEXT: CXXThisExpr 0x{{[^ ]*}} <col:8> 'V *' this
     }
   };
 
   int b, c;
 
   [](){};
   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:8> '(lambda at {{.*}}:[[@LINE-1]]:3)'

clang/test/AST/ast-dump-lambda.cpp

 // CHECK-NEXT:    |         | | |-MoveConstructor exists simple trivial needs_implicit
 // CHECK-NEXT:    |         | | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
 // CHECK-NEXT:    |         | | |-MoveAssignment
 // CHECK-NEXT:    |         | | `-Destructor simple irrelevant trivial needs_implicit
 // CHECK-NEXT:    |         | |-CXXMethodDecl {{.*}} <col:13, col:16> col:7{{( imported)?}} operator() 'auto () const -> auto' inline
 // CHECK-NEXT:    |         | | `-CompoundStmt {{.*}} <col:15, col:16>
 // CHECK-NEXT:    |         | `-FieldDecl {{.*}} <col:8> col:8{{( imported)?}} implicit 'V'
 // CHECK-NEXT:    |         |-ParenListExpr {{.*}} <col:8> 'NULL TYPE'
-// CHECK-NEXT:    |         | `-UnaryOperator {{.*}} <col:8> '<dependent type>' prefix '*' cannot overflow
+// CHECK-NEXT:    |         | `-UnaryOperator {{.*}} <col:8> 'V' lvalue prefix '*' cannot overflow
 // CHECK-NEXT:    |         |   `-CXXThisExpr {{.*}} <col:8> 'V *' this
 // CHECK-NEXT:    |         `-CompoundStmt {{.*}} <col:15, col:16>
 // CHECK-NEXT:    |-DeclStmt {{.*}} <line:22:3, col:11>
 // CHECK-NEXT:    | |-VarDecl {{.*}} <col:3, col:7> col:7{{( imported)?}} referenced b 'int'
 // CHECK-NEXT:    | `-VarDecl {{.*}} <col:3, col:10> col:10{{( imported)?}} referenced c 'int'
 // CHECK-NEXT:    |-LambdaExpr {{.*}} <line:23:3, col:9> '(lambda at {{.*}}ast-dump-lambda.cpp:23:3)'
 // CHECK-NEXT:    | |-CXXRecordDecl {{.*}} <col:3> col:3{{( imported)?}} implicit{{( <undeserialized declarations>)?}} class definition
 // CHECK-NEXT:    | | |-DefinitionData lambda empty standard_layout trivially_copyable literal can_const_default_init

clang/test/CXX/over/over.built/ast-20.cpp

 // RUN: %clang_cc1 -std=c++20 -ast-dump %s -ast-dump-filter Test | FileCheck %s
 
 namespace std {
   struct strong_ordering {
     int n;
     constexpr operator int() const { return n; }
     static const strong_ordering less, equal, greater;
   };
   constexpr strong_ordering strong_ordering::less{-1},
       strong_ordering::equal{0}, strong_ordering::greater{1};
 }
 
 template <typename T, typename U>
 auto Test(T* pt, U* pu) {
   // CHECK: BinaryOperator {{.*}} '<dependent type>' '<=>'
+  // CHECK-NEXT: ImplicitCastExpr {{.*}} 'T *' <LValueToRValue>
   // CHECK-NEXT: DeclRefExpr {{.*}} 'T *' lvalue ParmVar {{.*}} 'pt' 'T *'
+  // CHECK-NEXT: ImplicitCastExpr {{.*}} 'U *' <LValueToRValue>
   // CHECK-NEXT: DeclRefExpr {{.*}} 'U *' lvalue ParmVar {{.*}} 'pu' 'U *'
   (void)(pt <=> pu);
 
 }
 
 

clang/test/CXX/over/over.built/ast.cpp

 // RUN: %clang_cc1 -std=c++17 -ast-dump %s -ast-dump-filter Test | FileCheck %s
 
 struct A{};
 
 template <typename T, typename U>
 auto Test(T* pt, U* pu) {
-  // CHECK: UnaryOperator {{.*}} '<dependent type>' prefix '*'
+  // CHECK: UnaryOperator {{.*}} 'T' lvalue prefix '*'
+  // CHECK-NEXT: ImplicitCastExpr {{.*}} 'T *' <LValueToRValue>
   // CHECK-NEXT: DeclRefExpr {{.*}} 'T *' lvalue ParmVar {{.*}} 'pt' 'T *'
   (void)*pt;
 
-  // CHECK: UnaryOperator {{.*}} '<dependent type>' prefix '++'
+  // CHECK: UnaryOperator {{.*}} 'T *' lvalue prefix '++'
   // CHECK-NEXT: DeclRefExpr {{.*}} 'T *' lvalue ParmVar {{.*}} 'pt' 'T *'
   (void)(++pt);
 
-  // CHECK: UnaryOperator {{.*}} '<dependent type>' prefix '+'
+  // CHECK: UnaryOperator {{.*}} 'T *' prefix '+'
+  // CHECK-NEXT: ImplicitCastExpr {{.*}} 'T *' <LValueToRValue>
   // CHECK-NEXT: DeclRefExpr {{.*}} 'T *' lvalue ParmVar {{.*}} 'pt' 'T *'
   (void)(+pt);
 
-  // CHECK: BinaryOperator {{.*}} '<dependent type>' '+'
+  // CHECK: BinaryOperator {{.*}} 'T *' '+'
+  // CHECK-NEXT: ImplicitCastExpr {{.*}} 'T *' <LValueToRValue>
   // CHECK-NEXT: DeclRefExpr {{.*}} 'T *' lvalue ParmVar {{.*}} 'pt' 'T *'
   // CHECK-NEXT: IntegerLiteral {{.*}} 'int' 3
   (void)(pt + 3);
 
-  // CHECK: BinaryOperator {{.*}} '<dependent type>' '-'
+  // CHECK: BinaryOperator {{.*}} 'long' '-'
+  // CHECK-NEXT: ImplicitCastExpr {{.*}} 'T *' <LValueToRValue>
   // CHECK-NEXT: DeclRefExpr {{.*}} 'T *' lvalue ParmVar {{.*}} 'pt' 'T *'
+  // CHECK-NEXT: ImplicitCastExpr {{.*}} 'T *' <LValueToRValue>
   // CHECK-NEXT: DeclRefExpr {{.*}} 'T *' lvalue ParmVar {{.*}} 'pt' 'T *'
   (void)(pt - pt);
 
-  // CHECK: BinaryOperator {{.*}} '<dependent type>' '-'
+  // CHECK: BinaryOperator {{.*}} 'long' '-'
+  // CHECK-NEXT: ImplicitCastExpr {{.*}} 'T *' <LValueToRValue>
   // CHECK-NEXT: DeclRefExpr {{.*}} 'T *' lvalue ParmVar {{.*}} 'pt' 'T *'
+  // CHECK-NEXT: ImplicitCastExpr {{.*}} 'U *' <LValueToRValue>
   // CHECK-NEXT: DeclRefExpr {{.*}} 'U *' lvalue ParmVar {{.*}} 'pu' 'U *'
   (void)(pt - pu);
 
-  // CHECK: BinaryOperator {{.*}} '<dependent type>' '=='
+  // CHECK: BinaryOperator {{.*}} 'bool' '=='
+  // CHECK-NEXT: ImplicitCastExpr {{.*}} 'T *' <LValueToRValue>
   // CHECK-NEXT: DeclRefExpr {{.*}} 'T *' lvalue ParmVar {{.*}} 'pt' 'T *'
+  // CHECK-NEXT: ImplicitCastExpr {{.*}} 'U *' <LValueToRValue>
   // CHECK-NEXT: DeclRefExpr {{.*}} 'U *' lvalue ParmVar {{.*}} 'pu' 'U *'
   (void)(pt == pu);
 
 }
 
-

clang/test/CXX/over/over.built/p10.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s -Wno-tautological-compare
 
 struct A{};
 
 template <typename T>
-void f(int i, float f, bool b, char c, int* pi, A* pa, T* pt) {
+void f(int i, float f, bool b, char c, int* pi, A* pa, T* pt, T t) {
   (void)+i;
   (void)-i;
   (void)+f;
   (void)-f;
   (void)+b;
   (void)-b;
   (void)+c;
   (void)-c;
+  (void)+t;
+  (void)-t;
 
   (void)-pi; // expected-error {{invalid argument type}}
   (void)-pa; // expected-error {{invalid argument type}}
-  (void)-pt; // FIXME: we should be able to give an error here.
+  (void)-pt; // expected-error {{invalid argument type}}
 }
 

clang/test/CXX/over/over.built/p11.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s -Wno-tautological-compare
 
 template <typename T>
-void f(int i, float f, bool b, char c, int* pi, T* pt) {
+void f(int i, float f, bool b, char c, int* pi, T* pt, T t) {
   (void)~i;
   (void)~f; // expected-error {{invalid argument type}}
   (void)~b;
   (void)~c;
   (void)~pi; // expected-error {{invalid argument type}}
-  (void)~pt; // FIXME: we should be able to give an error here.
+  (void)~pt; // expected-error {{invalid argument type}}
+  (void)~t;
 }
 

clang/test/CXX/over/over.built/p13.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s -Wno-tautological-compare
 
 template <typename T>
-void f(int i, float f, bool b, char c, int* pi, T* pt) {
+void f(int i, float f, bool b, char c, int* pi, T* pt, T t) {
   (void)(i*i);
   (void)(i*f);
   (void)(i*b);
   (void)(i*c);
   (void)(i*pi); // expected-error {{invalid operands to binary expression}}
-  (void)(i*pt); // FIXME
+  (void)(i*pt); // expected-error {{invalid operands to binary expression}}
+  (void)(i*t);
 
   (void)(i/i);
   (void)(i/f);
   (void)(i/b);
   (void)(i/c);
   (void)(i/pi); // expected-error {{invalid operands to binary expression}}
-  (void)(i/pt); // FIXME
+  (void)(i/pt); // expected-error {{invalid operands to binary expression}}
+  (void)(i/t);
 
   (void)(i-i);
   (void)(i-f);
   (void)(i-b);
   (void)(i-c);
   (void)(i-pi); // expected-error {{invalid operands to binary expression}}
-  (void)(i-pt); // FIXME
+  (void)(i-pt); // expected-error {{invalid operands to binary expression}}
+  (void)(i-t);
 
   (void)(i<i);
   (void)(i<f);
   (void)(i<b);
   (void)(i<c);
   (void)(i<pi); // expected-error {{comparison between pointer and integer}}
-  (void)(i<pt); // FIXME
+  (void)(i<pt); // expected-error {{comparison between pointer and integer}}
+  (void)(i<t);
 
   (void)(i==i);
   (void)(i==f);
   (void)(i==b);
   (void)(i==c);
   (void)(i==pi); // expected-error {{comparison between pointer and integer}}
-  (void)(i==pt); // FIXME
+  (void)(i==pt); // expected-error {{comparison between pointer and integer}}
+  (void)(i==t);
 }
 

clang/test/CXX/over/over.built/p14.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s -Wno-tautological-compare
 
 template <typename T>
-void f(int* pi, T* pt) {
+void f(int* pi, T* pt, T t) {
   (void)(pi+3);
   (void)(3+pi);
   (void)(pi-3);
   (void)(pi[3]);
   (void)(3[pi]);
 
   (void)(pt+3);
   (void)(3+pt);
   (void)(pt-3);
   (void)(pt[3]);
   (void)(3[pt]);
+
+  (void)(t+3);
+  (void)(3+t);
+  (void)(t-3);
+  (void)(t[3]);
+  (void)(3[t]);
 }
 // expected-no-diagnostics

clang/test/CXX/over/over.built/p18.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s -Wno-tautological-compare
 
 template <typename T, typename U>
 void f(int i, float f, bool b, int* pi, T* pt, T t) {
   (void)(i % 3);
   (void)(f % 3);  // expected-error {{invalid operands}}
   (void)(b % 3);
   (void)(pi % 3); // expected-error {{invalid operands}}
-  (void)(pt % 3); // FIXME
+  (void)(pt % 3); // expected-error {{invalid operands}}
   (void)(t % 3);
   (void)(3 % i);
   (void)(3 % f);  // expected-error {{invalid operands}}
   (void)(3 % b);
   (void)(3 % pi); // expected-error {{invalid operands}}
-  (void)(3 % pt); // FIXME
+  (void)(3 % pt); // expected-error {{invalid operands}}
   (void)(3 % t);
 
   (void)(i & 3);
   (void)(f & 3);  // expected-error {{invalid operands}}
   (void)(b & 3);
   (void)(pi & 3); // expected-error {{invalid operands}}
-  (void)(pt & 3); // FIXME
+  (void)(pt & 3); // expected-error {{invalid operands}}
   (void)(t & 3);
   (void)(3 & i);
   (void)(3 & f);  // expected-error {{invalid operands}}
   (void)(3 & b);
   (void)(3 & pi); // expected-error {{invalid operands}}
-  (void)(3 & pt); // FIXME
+  (void)(3 & pt); // expected-error {{invalid operands}}
   (void)(3 & t);
 
   (void)(i ^ 3);
   (void)(f ^ 3);  // expected-error {{invalid operands}}
   (void)(b ^ 3);
   (void)(pi ^ 3); // expected-error {{invalid operands}}
-  (void)(pt ^ 3); // FIXME
+  (void)(pt ^ 3); // expected-error {{invalid operands}}
   (void)(t ^ 3);
   (void)(3 ^ i);
   (void)(3 ^ f);  // expected-error {{invalid operands}}
   (void)(3 ^ b);
   (void)(3 ^ pi); // expected-error {{invalid operands}}
-  (void)(3 ^ pt); // FIXME
+  (void)(3 ^ pt); // expected-error {{invalid operands}}
   (void)(3 ^ t);
 
   (void)(i | 3);
   (void)(f | 3);  // expected-error {{invalid operands}}
   (void)(b | 3);
   (void)(pi | 3); // expected-error {{invalid operands}}
-  (void)(pt | 3); // FIXME
+  (void)(pt | 3); // expected-error {{invalid operands}}
   (void)(t | 3);
   (void)(3 | i);
   (void)(3 | f);  // expected-error {{invalid operands}}
   (void)(3 | b);
   (void)(3 | pi); // expected-error {{invalid operands}}
-  (void)(3 | pt); // FIXME
+  (void)(3 | pt); // expected-error {{invalid operands}}
   (void)(3 | t);
 
   (void)(i << 3);
   (void)(f << 3);  // expected-error {{invalid operands}}
   (void)(b << 3);
   (void)(pi << 3); // expected-error {{invalid operands}}
-  (void)(pt << 3); // FIXME
+  (void)(pt << 3); // expected-error {{invalid operands}}
   (void)(t << 3);
   (void)(3 << i);
   (void)(3 << f);  // expected-error {{invalid operands}}
   (void)(3 << b);
   (void)(3 << pi); // expected-error {{invalid operands}}
-  (void)(3 << pt); // FIXME
+  (void)(3 << pt); // expected-error {{invalid operands}}
   (void)(3 << t);
 
   (void)(i >> 3);
   (void)(f >> 3);  // expected-error {{invalid operands}}
   (void)(b >> 3);
   (void)(pi >> 3); // expected-error {{invalid operands}}
-  (void)(pt >> 3); // FIXME
+  (void)(pt >> 3); // expected-error {{invalid operands}}
   (void)(t >> 3);
   (void)(3 >> i);
   (void)(3 >> f);  // expected-error {{invalid operands}}
   (void)(3 >> b);
   (void)(3 >> pi); // expected-error {{invalid operands}}
-  (void)(3 >> pt); // FIXME
+  (void)(3 >> pt); // expected-error {{invalid operands}}
   (void)(3 >> t);
 }

clang/test/CXX/over/over.built/p19.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s -Wno-tautological-compare
 
 template <typename T>
 void f(int i, float f, int* pi, T* pt, T t) {
   i = i;
   i *= i;
   i /= i;
   i += i;
   i -= i;
   i -= f;
   i -= pi; // expected-error {{invalid operands}}
-  i -= pt; // FIXME
+  i -= pt; // expected-error {{invalid operands}}
   i -= t;
 
   f = f;
   f *= f;
   f /= f;
   f += f;
   f -= f;
   f -= i;
   f -= pi; // expected-error {{invalid operands}}
-  f -= pt; // FIXME
+  f -= pt; // expected-error {{invalid operands}}
   f -= t;
 }

clang/test/CXX/over/over.built/p20.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s -Wno-tautological-compare
 
-template <typename T, typename U>
-void f(int* pi, float* pf, T* pt, U* pu, T t) {
+template <typename T>
+void f(int i, int* pi, T* pt, T t) {
+  i = i;
   pi = pi;
-  pi = pf; // expected-error {{incompatible pointer types}}
-  pi = pt;
-  pu = pi;
-  pu = pt;
-  pi = t;
-  pu = t;
+  pt = pt;
+  i = pi;   // expected-error {{incompatible pointer to integer}}
+  i = pt;   // FIXME
+  pi = i;   // expected-error {{incompatible integer to pointer}}
+  pt = i;   // FIXME
+  pi = pt;  // Checked during instantiation.
+  pi = t;   // Checked during instantiation.
 }
+

clang/test/CXX/over/over.built/p22.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s -Wno-tautological-compare
 
 template <typename T>
 void f(int* pi, T* pt, T t) {
   pi += 3;
   pi += pi; // expected-error {{invalid operands}}
   pt += 3;
   pi += t;
-  pi += pt; // FIXME
-  pt += pi; //FIXME
-  pt += pt; //FIXME
+  pi += pt; // expected-error {{invalid operands}}
+  pt += pi; // expected-error {{invalid operands}}
+  pt += pt; // expected-error {{invalid operands}}
 }

clang/test/CXX/over/over.built/p23.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s -Wno-tautological-compare
 
 template <typename T, typename U>
 void f(int i, float f, bool b, int* pi, T* pt, T t) {
   i %= 3;
   f %= 3;  // expected-error {{invalid operands}}
   b %= 3;
   pi %= 3; // expected-error {{invalid operands}}
-  pt %= 3; // FIXME
+  pt %= 3; // expected-error {{invalid operands}}
   t %= 3;
 
   i &= 3;
   f &= 3;  // expected-error {{invalid operands}}
   b &= 3;
   pi &= 3; // expected-error {{invalid operands}}
-  pt &= 3; // FIXME
+  pt &= 3; // expected-error {{invalid operands}}
   t &= 3;
 
   i ^= 3;
   f ^= 3;  // expected-error {{invalid operands}}
   b ^= 3;
   pi ^= 3; // expected-error {{invalid operands}}
-  pt ^= 3; // FIXME
+  pt ^= 3; // expected-error {{invalid operands}}
   t ^= 3;
 
   i |= 3;
   f |= 3;  // expected-error {{invalid operands}}
   b |= 3;
   pi |= 3; // expected-error {{invalid operands}}
-  pt |= 3; // FIXME
+  pt |= 3; // expected-error {{invalid operands}}
   t |= 3;
 
   i <<= 3;
   f <<= 3;  // expected-error {{invalid operands}}
   b <<= 3;
   pi <<= 3; // expected-error {{invalid operands}}
-  pt <<= 3; // FIXME
+  pt <<= 3; // expected-error {{invalid operands}}
   t <<= 3;
 
   i >>= 3;
   f >>= 3;  // expected-error {{invalid operands}}
   b >>= 3;
   pi >>= 3; // expected-error {{invalid operands}}
-  pt >>= 3; // FIXME
+  pt >>= 3; // expected-error {{invalid operands}}
   t >>= 3;
 }

clang/test/CXX/over/over.built/p4.cpp

 // RUN: %clang_cc1 -std=c++17 -verify %s -Wno-tautological-compare
 
-void f(int i, bool b) {
+template <typename T>
+void f(int i, bool b, T t) {
   (void)++i;
   (void)i++;
 
   (void)++b; // expected-error {{ISO C++17 does not allow incrementing expression of type bool}}
   (void)b++; // expected-error {{ISO C++17 does not allow incrementing expression of type bool}}
+
+  (void)++t;
+  (void)t++;
 }
 

clang/test/CXX/over/over.built/p5.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s -Wno-tautological-compare
 
-void f(int i, bool b) {
+template <typename T>
+void f(int i, bool b, T t) {
   (void)--i;
   (void)i--;
 
   (void)--b; // expected-error {{cannot decrement expression of type bool}}
   (void)b--; // expected-error {{cannot decrement expression of type bool}}
+
+  (void)--t;
+  (void)t--;
 }
 

clang/test/CXX/over/over.built/p7.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s -Wno-tautological-compare
 
 struct A{};
 
 template <typename T>
-void f(int* pi, A* pa, T* pt) {
+void f(int* pi, A* pa, T* pt, T t) {
   (void)*pi;
   (void)*pa;
   (void)*pt;
+  (void)*t;  // `T` might be a `U*`.
 }
 // expected-no-diagnostics
 

clang/test/CXX/over/over.built/spaceship.cpp

 // RUN: %clang_cc1 -std=c++20 -verify %s -Wno-tautological-compare
 
 namespace std {
   struct strong_ordering {
     int n;
     constexpr operator int() const { return n; }
     static const strong_ordering less, equal, greater;
   };
   constexpr strong_ordering strong_ordering::less{-1},
       strong_ordering::equal{0}, strong_ordering::greater{1};
 }
 
 template <typename T>
-void f(int i, float f, int* pi, T* pt, T t) {
+void f(int i, int* pi, T* pt, T t) {
   (void)(i <=> i);
-  (void)(i <=> f); // expected-error {{invalid argument type}}
-  (void)(i <=> pi); // expected-error {{invalid argument type}}
-  (void)(i <=> pt); // expected-error {{invalid argument type}}
+  (void)(i <=> pi); // expected-error {{comparison between pointer and integer}}
+  (void)(i <=> pt); // expected-error {{comparison between pointer and integer}}
   (void)(pi <=> pt);
   (void)(pi <=> t);
 }
 

clang/test/Frontend/noderef_templates.cpp

 // RUN: %clang_cc1 -verify %s
 
 #define NODEREF __attribute__((noderef))
 
 template <typename T>
-int func(T NODEREF *a) { // expected-note 2 {{a declared here}}
-  return *a + 1;         // expected-warning 2 {{dereferencing a; was declared with a 'noderef' type}}
+int func(T NODEREF *a) { // expected-note 3 {{a declared here}}
+  return *a + 1;         // expected-warning 3 {{dereferencing a; was declared with a 'noderef' type}}
 }
 
 void func() {
   float NODEREF *f;
   int NODEREF *i;
   func(f); // expected-note{{in instantiation of function template specialization 'func<float>' requested here}}
   func(i); // expected-note{{in instantiation of function template specialization 'func<int>' requested here}}
 }

clang/test/SemaTemplate/dependent-type-identity.cpp

struct X1 {
   void f7(typename N::X2<U>::template apply<U> *);
   void f7(typename N::X2<U>::template apply<T> *);
   void f7(typename X2<type>::template apply<U_type> *); // expected-error{{redeclar}}
 
   void f8(typename N::X2<T>::template apply<U> *); // expected-note{{previous}}
   void f8(typename N::X2<U>::template apply<U> *);
   void f8(typename N::X2<U>::template apply<T> *);
   void f8(typename ::Nalias::X2<type>::template apply<U_type> *); // expected-error{{redeclar}}
+
+  // (17.4.2): If an expression e is type-dependent (17.6.2.2), decltype(e)
+  // denotes a unique dependent type. Two such decltype-specifiers refer to the
+  // same type only if their expressions are equivalent (17.5.6.1)
+  T* a;
+  T* b;
+  using V = decltype(*a);
+  void f9(decltype(*a)); // expected-note{{previous}}
+  void f9(decltype(*b));
+  void f9(V); // expected-error{{redeclar}}
 };
 
 namespace PR6851 {
   template <bool v>
   struct S;
 
   struct N {
     template <bool w>