[Sema] Store a SourceRange for multi-token builtin types

[malcolm.parsons]

Summary

clang-tidy's modernize-use-auto check uses the SourceRange of a
TypeLoc when replacing the type with auto.
This was producing the wrong result for multi-token builtin types
like long long:

-long long *ll = new long long();
+auto long *ll = new long long();

[Prazek]

Thanks for the patch! I think some unit test should be added.

Do you also handle cases like

unsigned long long
unsigned volatile long const long static

etc.
The problem here is that the whole type like "unsigned long long" could be in other tokens.
I talked with Richard Smith while ago and one of the solutions proposed was to have "isValid()" for source range
returning false for cases like this

unsigned const long

include/clang/AST/TypeLoc.h

529

Can you add a comment here? It might be because I don't know the AST API, but it is not clear for me what does it do.

lib/Sema/DeclSpec.cpp

621

What about cases like

unsigned int
unsigned long

This is not only about long.

[malcolm.parsons]

In D25363#565371, @Prazek wrote:

Thanks for the patch! I think some unit test should be added.

Are there any existing unit tests for TypeLoc that I can add to?

Do you also handle cases like

unsigned long long

Yes - see tests in D25316.

The problem here is that the whole type like "unsigned long long" could be in other tokens.
I talked with Richard Smith while ago and one of the solutions proposed was to have "isValid()" for source range
returning false for cases like this

unsigned const long

I see. I hope that's a rare case that I can ignore for now.

lib/Sema/DeclSpec.cpp

621

for unsigned int, DeclSpec::SetTypeSpecSign() sets TSSLoc to the location of unsigned and DeclSpec::SetTypeSpecType() sets TSTLoc to the location of int so VisitBuiltinTypeLoc() already has the whole range available.

for unsigned long, DeclSpec::SetTypeSpecSign() sets TSSLoc to the location of unsigned and DeclSpec::SetTypeSpecWidth() sets TSWLoc to the location of long so VisitBuiltinTypeLoc() already has the whole range available.

The sign and type parts can't appear more than once, but the width part can.
I'm treating the final width part as being the type part.
This works for long long and long long int, but it looks like it would have issues with int long long.
Maybe TSWLoc should be replaced by a range.

[malcolm.parsons]

Replace TSWLoc with TSWRange

[malcolm.parsons]

I've tested this with clang-query using match typeLoc() and a lot of permutations of int, short, long, unsigned and const.

[Prazek]

In D25363#565445, @malcolm.parsons wrote:

In D25363#565371, @Prazek wrote:

Thanks for the patch! I think some unit test should be added.

Are there any existing unit tests for TypeLoc that I can add to?

Do you also handle cases like

unsigned long long

Yes - see tests in D25316.

The problem here is that the whole type like "unsigned long long" could be in other tokens.
I talked with Richard Smith while ago and one of the solutions proposed was to have "isValid()" for source range
returning false for cases like this

unsigned const long

I see. I hope that's a rare case that I can ignore for now.

I think there are some. Look at unittests/AST/ or unittests/ASTMatchers/. Sorry for being not so precise, but can't check it right now. I can check it later if you won't find it.

[Prazek]

In D25363#565472, @malcolm.parsons wrote:

I've tested this with clang-query using match typeLoc() and a lot of permutations of int, short, long, unsigned and const.

I am pretty sure it works, but someone could change the implementation and break your check without knowing it - not everyone compile and tests clang-extra, so we should have independent test.

[malcolm.parsons]

Ensure SourceRange is initialized

[malcolm.parsons]

Add unit tests

[malcolm.parsons]

ping.

[aaron.ballman]

include/clang/AST/TypeLoc.h

513

Since this doubles the size of the type loc for builtin types, do you happen to have any data on what practical impact this has on RAM usage, say for bootstrapping LLVM (or compiling any large source base, really)? Hopefully it's not a lot, but it would be nice to know if it's a .1%, 1%, 10%, etc increase in usage (or does the change get lost in the noise).

unittests/AST/SourceLocationTest.cpp

228

Can you also add a test that the range is correct for something like long double and long double _Complex?

[malcolm.parsons]

include/clang/AST/TypeLoc.h

513

I don't have any data.
I'm not sure how to collect that data.

[malcolm.parsons]

unittests/AST/SourceLocationTest.cpp

228

ComplexTypeLoc isn't implemented.

include/clang/AST/TypeLoc.h:

// FIXME: location of the '_Complex' keyword.
class ComplexTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
                                                        ComplexTypeLoc,
                                                        ComplexType> {
};

[malcolm.parsons]

Add unit tests for long double.

[aaron.ballman]

include/clang/AST/TypeLoc.h

513

It's likely platform dependent, but I was thinking something as simple as looking at peak RAM usage between two different builds of the compiler. Something like top would probably work if you're on Linux (unless someone knows of a better way, I'm not strong on Linux).

unittests/AST/SourceLocationTest.cpp

228

Ah, neat, then don't worry about that one. :-)

[malcolm.parsons]

include/clang/AST/TypeLoc.h

513

Before:
/usr/bin/time clang++ ... -c llvm/tools/clang/lib/AST/ExprConstant.cpp
5.56user 0.13system 0:05.91elapsed 96%CPU (0avgtext+0avgdata 256820maxresident)k

After:
/usr/bin/time clang++ ... -c llvm/tools/clang/lib/AST/ExprConstant.cpp
5.67user 0.12system 0:05.98elapsed 97%CPU (0avgtext+0avgdata 256940maxresident)k

((256940 - 256820) / 256820) * 100 = 0.05%

[aaron.ballman]

include/clang/AST/TypeLoc.h

513

Thank you for this -- is there a bigger delta for compilation of LLVM as a whole? ExprConstant.cpp is an interesting case, but not really representative of the project as a whole (for instance, there's not a lot of template metaprogramming in ExprConstant.cpp).

[malcolm.parsons]

include/clang/AST/TypeLoc.h

513

I can try running time on a full build.
For every file I sampled the increase was 0.05%.
Do TypeLocs increase when using TMP?

[aaron.ballman]

include/clang/AST/TypeLoc.h

513

I *think* that template arguments use TypeLocs, but I could be remembering incorrectly (and I unfortunately won't have the chance to check until next week sometime). I was asking for the whole project just in case there is some construct that has a heavier use of them. Your findings of .05% are really promising though.

[malcolm.parsons]

include/clang/AST/TypeLoc.h

513

Time reports max resident for building lib dir of llvm as 480780 before, 480920 after.
0.03%

[aaron.ballman]

LGTM!

include/clang/AST/TypeLoc.h

513

Awesome, thank you for getting this information; this seems like a reasonable consumption change to me.

[malcolm.parsons]

include/clang/AST/TypeLoc.h

533

I suspect that using min and max on SourceLocations is only valid if both locations are in the same file.

Doing this
long.h:

long

unsigned.cpp:

unsigned
#include "long.h"
i;

causes
clang-query> match typeLoc()
...
clang-query: llvm/tools/clang/lib/Frontend/DiagnosticRenderer.cpp:273: clang::SourceLocation retrieveMacroLocation(clang::SourceLocation, clang::FileID, clang::FileID, const llvm::SmallVectorImpl<clang::FileID>&, bool, const clang::SourceManager*): Assertion `SM->getFileID(Loc) == MacroFileID' failed.

Is there a better way to combine SourceRanges, or should the final range be accumulated in DeclSpec.cpp?

[aaron.ballman]

include/clang/AST/TypeLoc.h

533

Hmm, that's a good point, but I'm not aware of a better utility. Perhaps @rsmith knows of one?

[malcolm.parsons]

include/clang/AST/TypeLoc.h

533

I get the same assertion failure from a clang-query without my changes if I match a CompoundStmt that starts and ends in different files.
So I don't think it's my fault.
It's also a very rare case.
OK to commit?

[aaron.ballman]

include/clang/AST/TypeLoc.h

533

Thank you for checking. I think you are okay to commit, we can correct the bug in another patch. However, if you wouldn't mind filing a bug in bugzilla so that we don't lose this information, that would be great.

[malcolm.parsons]

include/clang/AST/TypeLoc.h

533

PR30765.

include/clang/AST/TypeLoc.h

 
 private:
   friend class TypeLoc;
   static bool isKind(const TypeLoc &TL);
 };
 
 
 struct BuiltinLocInfo {
-  SourceLocation BuiltinLoc;
+  SourceRange BuiltinRange;
 };
 
 /// \brief Wrapper for source info for builtin types.
 class BuiltinTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
                                               BuiltinTypeLoc,
                                               BuiltinType,
                                               BuiltinLocInfo> {
 public:
   SourceLocation getBuiltinLoc() const {
-    return getLocalData()->BuiltinLoc;
+    return getLocalData()->BuiltinRange.getBegin();
   }
   void setBuiltinLoc(SourceLocation Loc) {
-    getLocalData()->BuiltinLoc = Loc;
+    getLocalData()->BuiltinRange = Loc;
+  }
+  void expandBuiltinRange(SourceRange Range) {
+    SourceRange &BuiltinRange = getLocalData()->BuiltinRange;
+    if (!BuiltinRange.getBegin().isValid()) {
+      BuiltinRange = Range;
+    } else {
+      BuiltinRange.setBegin(std::min(Range.getBegin(), BuiltinRange.getBegin()));
+      BuiltinRange.setEnd(std::max(Range.getEnd(), BuiltinRange.getEnd()));
+    }
   }
 
   SourceLocation getNameLoc() const { return getBuiltinLoc(); }
 
   WrittenBuiltinSpecs& getWrittenBuiltinSpecs() {
     return *(static_cast<WrittenBuiltinSpecs*>(getExtraLocalData()));
   }
   const WrittenBuiltinSpecs& getWrittenBuiltinSpecs() const {
unsigned getExtraLocalDataSize() const {
     return needsExtraLocalData() ? sizeof(WrittenBuiltinSpecs) : 0;
   }
 
   unsigned getExtraLocalDataAlignment() const {
     return needsExtraLocalData() ? llvm::alignOf<WrittenBuiltinSpecs>() : 1;
   }
 
   SourceRange getLocalSourceRange() const {
-    return SourceRange(getBuiltinLoc(), getBuiltinLoc());
+    return getLocalData()->BuiltinRange;
   }
 
   TypeSpecifierSign getWrittenSignSpec() const {
     if (needsExtraLocalData())
       return static_cast<TypeSpecifierSign>(getWrittenBuiltinSpecs().Sign);
     else
       return TSS_unspecified;
   }

include/clang/Sema/DeclSpec.h

private:
   // Scope specifier for the type spec, if applicable.
   CXXScopeSpec TypeScope;
 
   // SourceLocation info.  These are null if the item wasn't specified or if
   // the setting was synthesized.
   SourceRange Range;
 
   SourceLocation StorageClassSpecLoc, ThreadStorageClassSpecLoc;
-  SourceLocation TSWLoc, TSCLoc, TSSLoc, TSTLoc, AltiVecLoc;
+  SourceRange TSWRange;
+  SourceLocation TSCLoc, TSSLoc, TSTLoc, AltiVecLoc;
   /// TSTNameLoc - If TypeSpecType is any of class, enum, struct, union,
   /// typename, then this is the location of the named type (if present);
   /// otherwise, it is the same as TSTLoc. Hence, the pair TSTLoc and
   /// TSTNameLoc provides source range info for tag types.
   SourceLocation TSTNameLoc;
   SourceRange TypeofParensRange;
   SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc,
       TQ_unalignedLoc;
public:
   }
   CXXScopeSpec &getTypeSpecScope() { return TypeScope; }
   const CXXScopeSpec &getTypeSpecScope() const { return TypeScope; }
 
   SourceRange getSourceRange() const LLVM_READONLY { return Range; }
   SourceLocation getLocStart() const LLVM_READONLY { return Range.getBegin(); }
   SourceLocation getLocEnd() const LLVM_READONLY { return Range.getEnd(); }
 
-  SourceLocation getTypeSpecWidthLoc() const { return TSWLoc; }
+  SourceLocation getTypeSpecWidthLoc() const { return TSWRange.getBegin(); }
+  SourceRange getTypeSpecWidthRange() const { return TSWRange; }
   SourceLocation getTypeSpecComplexLoc() const { return TSCLoc; }
   SourceLocation getTypeSpecSignLoc() const { return TSSLoc; }
   SourceLocation getTypeSpecTypeLoc() const { return TSTLoc; }
   SourceLocation getAltiVecLoc() const { return AltiVecLoc; }
 
   SourceLocation getTypeSpecTypeNameLoc() const {
     assert(isDeclRep((TST) TypeSpecType) || TypeSpecType == TST_typename);
     return TSTNameLoc;

lib/Sema/DeclSpec.cpp

 
 /// These methods set the specified attribute of the DeclSpec, but return true
 /// and ignore the request if invalid (e.g. "extern" then "auto" is
 /// specified).
 bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc,
                                 const char *&PrevSpec,
                                 unsigned &DiagID,
                                 const PrintingPolicy &Policy) {
-  // Overwrite TSWLoc only if TypeSpecWidth was unspecified, so that
+  // Overwrite TSWRange.Begin only if TypeSpecWidth was unspecified, so that
   // for 'long long' we will keep the source location of the first 'long'.
   if (TypeSpecWidth == TSW_unspecified)
-    TSWLoc = Loc;
+    TSWRange.setBegin(Loc);
   // Allow turning long -> long long.
   else if (W != TSW_longlong || TypeSpecWidth != TSW_long)
     return BadSpecifier(W, (TSW)TypeSpecWidth, PrevSpec, DiagID);
   TypeSpecWidth = W;
+  // Remember location of the last 'long'
+  TSWRange.setEnd(Loc);
   return false;
 }
 
 bool DeclSpec::SetTypeSpecComplex(TSC C, SourceLocation Loc,
                                   const char *&PrevSpec,
                                   unsigned &DiagID) {
   if (TypeSpecComplex != TSC_unspecified)
     return BadSpecifier(C, (TSC)TypeSpecComplex, PrevSpec, DiagID);
void DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {
   if (TypeSpecType == TST_decltype_auto &&
       (TypeSpecWidth != TSW_unspecified ||
        TypeSpecComplex != TSC_unspecified ||
        TypeSpecSign != TSS_unspecified ||
        TypeAltiVecVector || TypeAltiVecPixel || TypeAltiVecBool ||
        TypeQualifiers)) {
     const unsigned NumLocs = 9;
     SourceLocation ExtraLocs[NumLocs] = {
-      TSWLoc, TSCLoc, TSSLoc, AltiVecLoc,
-      TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc, TQ_unalignedLoc
-    };
+        TSWRange.getBegin(), TSCLoc,       TSSLoc,
+        AltiVecLoc,          TQ_constLoc,  TQ_restrictLoc,
+        TQ_volatileLoc,      TQ_atomicLoc, TQ_unalignedLoc};
     FixItHint Hints[NumLocs];
     SourceLocation FirstLoc;
     for (unsigned I = 0; I != NumLocs; ++I) {
       if (ExtraLocs[I].isValid()) {
         if (FirstLoc.isInvalid() ||
             S.getSourceManager().isBeforeInTranslationUnit(ExtraLocs[I],
                                                            FirstLoc))
           FirstLoc = ExtraLocs[I];
if (TypeAltiVecBool) {
         S.Diag(TSTLoc, diag::err_invalid_vector_bool_decl_spec)
           << (TypeAltiVecPixel ? "__pixel" :
                                  getSpecifierName((TST)TypeSpecType, Policy));
       }
 
       // Only 'short' and 'long long' are valid with vector bool. (PIM 2.1)
       if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short) &&
           (TypeSpecWidth != TSW_longlong))
-        S.Diag(TSWLoc, diag::err_invalid_vector_bool_decl_spec)
+        S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_bool_decl_spec)
             << getSpecifierName((TSW)TypeSpecWidth);
 
       // vector bool long long requires VSX support or ZVector.
       if ((TypeSpecWidth == TSW_longlong) &&
           (!S.Context.getTargetInfo().hasFeature("vsx")) &&
           (!S.Context.getTargetInfo().hasFeature("power8-vector")) &&
           !S.getLangOpts().ZVector)
         S.Diag(TSTLoc, diag::err_invalid_vector_long_long_decl_spec);
 
       // Elements of vector bool are interpreted as unsigned. (PIM 2.1)
       if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) ||
           (TypeSpecWidth != TSW_unspecified))
         TypeSpecSign = TSS_unsigned;
     } else if (TypeSpecType == TST_double) {
       // vector long double and vector long long double are never allowed.
       // vector double is OK for Power7 and later, and ZVector.
       if (TypeSpecWidth == TSW_long || TypeSpecWidth == TSW_longlong)
-        S.Diag(TSWLoc, diag::err_invalid_vector_long_double_decl_spec);
+        S.Diag(TSWRange.getBegin(),
+               diag::err_invalid_vector_long_double_decl_spec);
       else if (!S.Context.getTargetInfo().hasFeature("vsx") &&
                !S.getLangOpts().ZVector)
         S.Diag(TSTLoc, diag::err_invalid_vector_double_decl_spec);
     } else if (TypeSpecType == TST_float) {
       // vector float is unsupported for ZVector.
       if (S.getLangOpts().ZVector)
         S.Diag(TSTLoc, diag::err_invalid_vector_float_decl_spec);
     } else if (TypeSpecWidth == TSW_long) {
       // vector long is unsupported for ZVector and deprecated for AltiVec.
       if (S.getLangOpts().ZVector)
-        S.Diag(TSWLoc, diag::err_invalid_vector_long_decl_spec);
+        S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_long_decl_spec);
       else
-        S.Diag(TSWLoc, diag::warn_vector_long_decl_spec_combination)
+        S.Diag(TSWRange.getBegin(),
+               diag::warn_vector_long_decl_spec_combination)
             << getSpecifierName((TST)TypeSpecType, Policy);
     }
 
     if (TypeAltiVecPixel) {
       //TODO: perform validation
       TypeSpecType = TST_int;
       TypeSpecSign = TSS_unsigned;
       TypeSpecWidth = TSW_short;
       TypeSpecOwned = false;
void DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {
   // Validate the width of the type.
   switch (TypeSpecWidth) {
   case TSW_unspecified: break;
   case TSW_short:    // short int
   case TSW_longlong: // long long int
     if (TypeSpecType == TST_unspecified)
       TypeSpecType = TST_int; // short -> short int, long long -> long long int.
     else if (TypeSpecType != TST_int) {
-      S.Diag(TSWLoc, diag::err_invalid_width_spec) << (int)TypeSpecWidth
-        <<  getSpecifierName((TST)TypeSpecType, Policy);
+      S.Diag(TSWRange.getBegin(), diag::err_invalid_width_spec)
+          << (int)TypeSpecWidth << getSpecifierName((TST)TypeSpecType, Policy);
       TypeSpecType = TST_int;
       TypeSpecOwned = false;
     }
     break;
   case TSW_long:  // long double, long int
     if (TypeSpecType == TST_unspecified)
       TypeSpecType = TST_int;  // long -> long int.
     else if (TypeSpecType != TST_int && TypeSpecType != TST_double) {
-      S.Diag(TSWLoc, diag::err_invalid_width_spec) << (int)TypeSpecWidth
-        << getSpecifierName((TST)TypeSpecType, Policy);
+      S.Diag(TSWRange.getBegin(), diag::err_invalid_width_spec)
+          << (int)TypeSpecWidth << getSpecifierName((TST)TypeSpecType, Policy);
       TypeSpecType = TST_int;
       TypeSpecOwned = false;
     }
     break;
   }
 
   // TODO: if the implementation does not implement _Complex or _Imaginary,
   // disallow their use.  Need information about the backend.

lib/Sema/SemaType.cpp

public:
     void VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
       // By default, use the source location of the type specifier.
       TL.setBuiltinLoc(DS.getTypeSpecTypeLoc());
       if (TL.needsExtraLocalData()) {
         // Set info for the written builtin specifiers.
         TL.getWrittenBuiltinSpecs() = DS.getWrittenBuiltinSpecs();
         // Try to have a meaningful source location.
         if (TL.getWrittenSignSpec() != TSS_unspecified)
-          // Sign spec loc overrides the others (e.g., 'unsigned long').
-          TL.setBuiltinLoc(DS.getTypeSpecSignLoc());
-        else if (TL.getWrittenWidthSpec() != TSW_unspecified)
-          // Width spec loc overrides type spec loc (e.g., 'short int').
-          TL.setBuiltinLoc(DS.getTypeSpecWidthLoc());
+          TL.expandBuiltinRange(DS.getTypeSpecSignLoc());
+        if (TL.getWrittenWidthSpec() != TSW_unspecified)
+          TL.expandBuiltinRange(DS.getTypeSpecWidthRange());
       }
     }
     void VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
       ElaboratedTypeKeyword Keyword
         = TypeWithKeyword::getKeywordForTypeSpec(DS.getTypeSpecType());
       if (DS.getTypeSpecType() == TST_typename) {
         TypeSourceInfo *TInfo = nullptr;
         Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);

unittests/AST/SourceLocationTest.cpp

 
 TEST(VarDecl, VMTypeFixedVarDeclRange) {
   RangeVerifier<VarDecl> Verifier;
   Verifier.expectRange(1, 1, 1, 23);
   EXPECT_TRUE(Verifier.match("int a[(int)(void*)1234];",
                              varDecl(), Lang_C89));
 }
 
+TEST(TypeLoc, IntRange) {
+  RangeVerifier<TypeLoc> Verifier;
+  Verifier.expectRange(1, 1, 1, 1);
+  EXPECT_TRUE(Verifier.match("int a;", typeLoc()));
+}
+
+TEST(TypeLoc, LongRange) {
+  RangeVerifier<TypeLoc> Verifier;
+  Verifier.expectRange(1, 1, 1, 1);
+  EXPECT_TRUE(Verifier.match("long a;", typeLoc()));
+}
+
+TEST(TypeLoc, LongIntRange) {
+  RangeVerifier<TypeLoc> Verifier;
+  Verifier.expectRange(1, 1, 1, 6);
+  EXPECT_TRUE(Verifier.match("long int a;", typeLoc()));
+}
+
+TEST(TypeLoc, IntLongRange) {
+  RangeVerifier<TypeLoc> Verifier;
+  Verifier.expectRange(1, 1, 1, 5);
+  EXPECT_TRUE(Verifier.match("int long a;", typeLoc()));
+}
+
+TEST(TypeLoc, UnsignedIntRange) {
+  RangeVerifier<TypeLoc> Verifier;
+  Verifier.expectRange(1, 1, 1, 10);
+  EXPECT_TRUE(Verifier.match("unsigned int a;", typeLoc()));
+}
+
+TEST(TypeLoc, IntUnsignedRange) {
+  RangeVerifier<TypeLoc> Verifier;
+  Verifier.expectRange(1, 1, 1, 5);
+  EXPECT_TRUE(Verifier.match("int unsigned a;", typeLoc()));
+}
+
+TEST(TypeLoc, LongLongRange) {
+  RangeVerifier<TypeLoc> Verifier;
+  Verifier.expectRange(1, 1, 1, 6);
+  EXPECT_TRUE(Verifier.match("long long a;", typeLoc()));
+}
+
+TEST(TypeLoc, UnsignedLongLongRange) {
+  RangeVerifier<TypeLoc> Verifier;
+  Verifier.expectRange(1, 1, 1, 15);
+  EXPECT_TRUE(Verifier.match("unsigned long long a;", typeLoc()));
+}
+
+TEST(TypeLoc, LongUnsignedLongRange) {
+  RangeVerifier<TypeLoc> Verifier;
+  Verifier.expectRange(1, 1, 1, 15);
+  EXPECT_TRUE(Verifier.match("long unsigned long a;", typeLoc()));
+}
+
+TEST(TypeLoc, LongLongUnsignedRange) {
+  RangeVerifier<TypeLoc> Verifier;
+  Verifier.expectRange(1, 1, 1, 11);
+  EXPECT_TRUE(Verifier.match("long long unsigned a;", typeLoc()));
+}
+
+TEST(TypeLoc, ConstLongLongRange) {
+  RangeVerifier<TypeLoc> Verifier;
+  Verifier.expectRange(1, 7, 1, 12);
+  EXPECT_TRUE(Verifier.match("const long long a = 0;", typeLoc()));
+}
+
+TEST(TypeLoc, LongConstLongRange) {
+  RangeVerifier<TypeLoc> Verifier;
+  Verifier.expectRange(1, 1, 1, 12);
+  EXPECT_TRUE(Verifier.match("long const long a = 0;", typeLoc()));
+}
+
+TEST(TypeLoc, LongLongConstRange) {
+  RangeVerifier<TypeLoc> Verifier;
+  Verifier.expectRange(1, 1, 1, 6);
+  EXPECT_TRUE(Verifier.match("long long const a = 0;", typeLoc()));
+}
+
 TEST(CXXConstructorDecl, NoRetFunTypeLocRange) {
   RangeVerifier<CXXConstructorDecl> Verifier;
   Verifier.expectRange(1, 11, 1, 13);
   EXPECT_TRUE(Verifier.match("class C { C(); };", functionDecl()));
 }
 
 TEST(CXXConstructorDecl, DefaultedCtorLocRange) {
   RangeVerifier<CXXConstructorDecl> Verifier;