maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/utils/ClangVisualizers/clang.natvis

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1044 lines
72 KiB
Plaintext
Raw Normal View History

Since Visual Studio 2012 is the minimum version of MSVC we support, the old-style visualizers are being removed. Adding a Natvis replacement for the debugging visualizers. llvm-svn: 200032
2014-01-25 03:46:45 +08:00
<?xml version="1.0" encoding="utf-8"?>
<!--
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
Visual Studio Native Debugging Visualizers for LLVM
Since Visual Studio 2012 is the minimum version of MSVC we support, the old-style visualizers are being removed. Adding a Natvis replacement for the debugging visualizers. llvm-svn: 200032
2014-01-25 03:46:45 +08:00
Use VS2015 Project Support for Natvis to eliminate the need to manually install clang native visualizer This is the clang equivalent to llvm commit 264601. When using Visual Studio 2015, cmake now puts the native visualizers in llvm.sln, so the developer automatically sees custom visualizations. Much thanks to ariccio who provided extensive help on this change. (manual installation still needed on VS2013). llvm-svn: 264603
2016-03-29 02:03:37 +08:00
For Visual Studio 2013 only, put this file into
"%USERPROFILE%\Documents\Visual Studio 2013\Visualizers" or create a symbolic link so it updates automatically.
For later versions of Visual Studio, no setup is required-->
Since Visual Studio 2012 is the minimum version of MSVC we support, the old-style visualizers are being removed. Adding a Natvis replacement for the debugging visualizers. llvm-svn: 200032
2014-01-25 03:46:45 +08:00
<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
Added MSVC natvis visualizers for Type and QualType. These could probably be improved, but anything is better than staring at hex values in the debugger. llvm-svn: 248808
2015-09-30 01:32:36 +08:00
<Type Name="clang::Type">
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<!-- To visualize clang::Types, we need to look at TypeBits.TC to determine the actual
type subclass and manually dispatch accordingly (Visual Studio can't identify the real type
because clang::Type has no virtual members hence no RTTI).
Views:
"cmn": Visualization that is common to all clang::Type subclasses
"poly": Visualization that is specific to the actual clang::Type subclass. The subtype-specific
<DisplayString> is typically as C++-like as possible (like in dump()) with <Expand>
containing all the gory details.
"cpp": Only occasionally used when we need to distinguish between an ordinary view and a C++-like view.
-->
Visual Studio Visualizers for ActionResult, LocInfoType, and and TypeSourceInfo Created a visualizer for ActionResult that displayed the validity and the pointer, but many of them initially displayed poorly. It turns out that the primary culprit is that LocInfoType is often passed in an action result, but it is not the same as other types. For example, LocInfoType is not in TypeNodes.def and clang::Type::TypeClass does not have a LocInfoType enum. After adding a special visualizer for LocInfoType, the display was more useful llvm-svn: 272487
2016-06-12 04:15:19 +08:00
<DisplayString IncludeView="cmn" Condition="TypeBits.TC==clang::LocInfoType::LocInfo">LocInfoType</DisplayString>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<DisplayString IncludeView="cmn">{(clang::Type::TypeClass)TypeBits.TC, en}Type</DisplayString>
<!-- Dispatch to visualizers for the actual Type subclass -->
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Builtin" IncludeView="poly">{*(clang::BuiltinType *)this}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Pointer" IncludeView="poly">{*(clang::PointerType *)this}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::LValueReference" IncludeView="poly">{*(clang::LValueReferenceType *)this}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::RValueReference" IncludeView="poly">{*(clang::RValueReferenceType *)this}</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::ConstantArray" IncludeView="poly">{(clang::ConstantArrayType *)this,na}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::ConstantArray" IncludeView="left">{(clang::ConstantArrayType *)this,view(left)na}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::ConstantArray" IncludeView="right">{(clang::ConstantArrayType *)this,view(right)na}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::IncompleteArray" IncludeView="poly">{(clang::IncompleteArrayType *)this,na}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::IncompleteArray" IncludeView="left">{(clang::IncompleteArrayType *)this,view(left)na}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::IncompleteArray" IncludeView="right">{(clang::IncompleteArrayType *)this,view(right)na}</DisplayString>
MSVC visualizers for type aliases For example, the following TypeAliasTemplateDecl now displays in the autos window as template<class T> using type_identity_t = type_identity<T>::type; llvm-svn: 364145
2019-06-23 09:15:48 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Typedef" IncludeView="poly">{(clang::TypedefType *)this,na}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Typedef" IncludeView="cpp">{(clang::TypedefType *)this,view(cpp)na}</DisplayString>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Attributed" IncludeView="poly">{*(clang::AttributedType *)this}</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Decayed" IncludeView="poly">{(clang::DecayedType *)this,na}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Decayed" IncludeView="left">{(clang::DecayedType *)this,view(left)na}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Decayed" IncludeView="right">{(clang::DecayedType *)this,view(right)na}</DisplayString>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::TemplateTypeParm" IncludeView="poly">{*(clang::TemplateTypeParmType *)this}</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::TemplateTypeParm" IncludeView="cpp">{*(clang::TemplateTypeParmType *)this,view(cpp)}</DisplayString>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::SubstTemplateTypeParm" IncludeView="poly">{*(clang::SubstTemplateTypeParmType *)this}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Record" IncludeView="poly">{*(clang::RecordType *)this}</DisplayString>
Visual Studio Native Visualizations for constructors and methods With this change, the class struct A { A(int _i); ~A(); int foo(double d); double bar(A *a) { return 1.3; } }; appears in the VS2015 Locals Window as D 0x02dbb378 struct A |- DeclKind CXXRecord |- Members |- [0] implicit struct A |- [1] Constructor {A(int _i)} |- [2] Destructor {~A()} |- [3] Method {int foo(double d)} |- [4] Method {double bar(struct A *)} |- [Raw View] /* Other stuff */ Note that these changes only benefit VS2015 as VS2013 does not have views and only displays the struct name "A", but the change does no apparent harm in VS2013, so is still a win. llvm-svn: 264020
2016-03-22 10:29:22 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Record" IncludeView="cpp">{*(clang::RecordType *)this,view(cpp)}</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::FunctionProto" IncludeView="poly">{(clang::FunctionProtoType *)this,na}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::FunctionProto" IncludeView="left">{(clang::FunctionProtoType *)this,view(left)na}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::FunctionProto" IncludeView="right">{(clang::FunctionProtoType *)this,view(right)na}</DisplayString>
Visual Studio native visualizer for InjectedClassNameType Also fixes some omissions for TemplateSpecializationType llvm-svn: 264710
2016-03-29 17:24:45 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::TemplateSpecialization" IncludeView="poly">{*(clang::TemplateSpecializationType *)this}</DisplayString>
Improve MSVC type visualizations Display TypeBits in a single line. Fix bit rot in template visualizations Rudimentary support for deduced types llvm-svn: 350470
2019-01-06 01:01:34 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::DeducedTemplateSpecialization" IncludeView="poly">{*(clang::DeducedTemplateSpecializationType *)this}</DisplayString>
Improve MSVC visualizers for DeclSpec and TemplateName DeclSpec now shows the TypeRep, ExprRep, or DeclRep as appropriate TemplateName decodes and displays the StorageType A few minor refinements to other types llvm-svn: 367199
2019-07-29 11:34:40 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::DeducedTemplateSpecialization" IncludeView="cpp">{*(clang::DeducedTemplateSpecializationType *)this,view(cpp)}</DisplayString>
Visual Studio native visualizer for InjectedClassNameType Also fixes some omissions for TemplateSpecializationType llvm-svn: 264710
2016-03-29 17:24:45 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::InjectedClassName" IncludeView="poly">{*(clang::InjectedClassNameType *)this}</DisplayString>
MSVC visualizers for type aliases For example, the following TypeAliasTemplateDecl now displays in the autos window as template<class T> using type_identity_t = type_identity<T>::type; llvm-svn: 364145
2019-06-23 09:15:48 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::DependentName" IncludeView="poly">{*(clang::DependentNameType *)this}</DisplayString>
Visual Studio Visualizer for PackExpansionType llvm-svn: 272522
2016-06-13 06:54:46 +08:00
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::PackExpansion" IncludeView="poly">{*(clang::PackExpansionType *)this}</DisplayString>
Improve MSVC visualization of annot_template_id tokens Now shows the actual annotated template. E.g., {annot_template_id (A<int, double>)} Also a few miscellaneous fixes to visualizers of other types llvm-svn: 365248
2019-07-06 05:41:30 +08:00
<DisplayString Condition="TypeBits.TC==clang::LocInfoType::LocInfo" IncludeView="poly">{(clang::LocInfoType *)this,na}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::LocInfoType::LocInfo" IncludeView="cpp">{(clang::LocInfoType *)this,view(cpp)na}</DisplayString>
<DisplayString IncludeView="cpp">{this,view(poly)na}</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="left">{*this,view(cpp)}</DisplayString>
<DisplayString IncludeView="right"></DisplayString>
Make clearer which clang::type subclasses have visualizers llvm-svn: 350182
2019-01-01 07:01:34 +08:00
<DisplayString IncludeView="poly">No visualizer yet for {(clang::Type::TypeClass)TypeBits.TC,en}Type</DisplayString> <!-- Not yet implemented Type subclass -->
Have MSVC Visualizer for DeducedTemplateSpecializationType show both the original template and deduced specialization Now appears in the Autos window something like - MyType DeducedTemplateSpecializationType {struct Y<int>} |- Template template<typename T> struct Y; |- Deduced As struct Y<int> |- isDeduced true bool |- TypeClass DeducedTemplateSpecialization (36) |- Flags No TypeBits set beyond TypeClass |- Canonical RecordType {struct Y<int>} Also changed QualType visualization to auto-expand the BaseType llvm-svn: 350487
2019-01-06 12:58:48 +08:00
<DisplayString IncludeView="Dependent" Condition="TypeBits.Dependent">Dependent{" ",sb}</DisplayString>
Improve MSVC type visualizations Display TypeBits in a single line. Fix bit rot in template visualizations Rudimentary support for deduced types llvm-svn: 350470
2019-01-06 01:01:34 +08:00
<DisplayString IncludeView="Dependent"></DisplayString>
Have MSVC Visualizer for DeducedTemplateSpecializationType show both the original template and deduced specialization Now appears in the Autos window something like - MyType DeducedTemplateSpecializationType {struct Y<int>} |- Template template<typename T> struct Y; |- Deduced As struct Y<int> |- isDeduced true bool |- TypeClass DeducedTemplateSpecialization (36) |- Flags No TypeBits set beyond TypeClass |- Canonical RecordType {struct Y<int>} Also changed QualType visualization to auto-expand the BaseType llvm-svn: 350487
2019-01-06 12:58:48 +08:00
<DisplayString IncludeView="InstantiationDependent" Condition="TypeBits.InstantiationDependent">InstantiationDependent{" ",sb}</DisplayString>
Improve MSVC type visualizations Display TypeBits in a single line. Fix bit rot in template visualizations Rudimentary support for deduced types llvm-svn: 350470
2019-01-06 01:01:34 +08:00
<DisplayString IncludeView="InstantiationDependent"></DisplayString>
Have MSVC Visualizer for DeducedTemplateSpecializationType show both the original template and deduced specialization Now appears in the Autos window something like - MyType DeducedTemplateSpecializationType {struct Y<int>} |- Template template<typename T> struct Y; |- Deduced As struct Y<int> |- isDeduced true bool |- TypeClass DeducedTemplateSpecialization (36) |- Flags No TypeBits set beyond TypeClass |- Canonical RecordType {struct Y<int>} Also changed QualType visualization to auto-expand the BaseType llvm-svn: 350487
2019-01-06 12:58:48 +08:00
<DisplayString IncludeView="VariablyModified" Condition="TypeBits.VariablyModified">VariablyModified{" ",sb}</DisplayString>
Improve MSVC type visualizations Display TypeBits in a single line. Fix bit rot in template visualizations Rudimentary support for deduced types llvm-svn: 350470
2019-01-06 01:01:34 +08:00
<DisplayString IncludeView="VariablyModified"></DisplayString>
Have MSVC Visualizer for DeducedTemplateSpecializationType show both the original template and deduced specialization Now appears in the Autos window something like - MyType DeducedTemplateSpecializationType {struct Y<int>} |- Template template<typename T> struct Y; |- Deduced As struct Y<int> |- isDeduced true bool |- TypeClass DeducedTemplateSpecialization (36) |- Flags No TypeBits set beyond TypeClass |- Canonical RecordType {struct Y<int>} Also changed QualType visualization to auto-expand the BaseType llvm-svn: 350487
2019-01-06 12:58:48 +08:00
<DisplayString IncludeView="ContainsUnexpandedParameterPack" Condition="TypeBits.ContainsUnexpandedParameterPack">ContainsUnexpandedParameterPack{" ",sb}</DisplayString>
Improve MSVC type visualizations Display TypeBits in a single line. Fix bit rot in template visualizations Rudimentary support for deduced types llvm-svn: 350470
2019-01-06 01:01:34 +08:00
<DisplayString IncludeView="ContainsUnexpandedParameterPack"></DisplayString>
<DisplayString IncludeView="Cache" Condition="TypeBits.CacheValid &amp;&amp; TypeBits.CachedLocalOrUnnamed">CachedLinkage: {(clang::Linkage)TypeBits.CachedLinkage,en} CachedLocalOrUnnamed</DisplayString>
Have MSVC Visualizer for DeducedTemplateSpecializationType show both the original template and deduced specialization Now appears in the Autos window something like - MyType DeducedTemplateSpecializationType {struct Y<int>} |- Template template<typename T> struct Y; |- Deduced As struct Y<int> |- isDeduced true bool |- TypeClass DeducedTemplateSpecialization (36) |- Flags No TypeBits set beyond TypeClass |- Canonical RecordType {struct Y<int>} Also changed QualType visualization to auto-expand the BaseType llvm-svn: 350487
2019-01-06 12:58:48 +08:00
<DisplayString IncludeView="Cache" Condition="TypeBits.CacheValid &amp;&amp; !TypeBits.CachedLocalOrUnnamed">CachedLinkage: {(clang::Linkage)TypeBits.CachedLinkage,en}{" ",sb}</DisplayString>
Improve MSVC type visualizations Display TypeBits in a single line. Fix bit rot in template visualizations Rudimentary support for deduced types llvm-svn: 350470
2019-01-06 01:01:34 +08:00
<DisplayString IncludeView="Cache"></DisplayString>
<DisplayString IncludeView="FromAST" Condition="TypeBits.FromAST">FromAST</DisplayString>
<DisplayString IncludeView="FromAST"></DisplayString>
<DisplayString IncludeView="flags" Condition="!TypeBits.Dependent &amp;&amp; !TypeBits.InstantiationDependent &amp;&amp; !TypeBits.VariablyModified &amp;&amp; !TypeBits.ContainsUnexpandedParameterPack &amp;&amp; !TypeBits.CacheValid &amp;&amp; !TypeBits.FromAST">
No TypeBits set beyond TypeClass
</DisplayString>
<DisplayString IncludeView="flags">
Fix MSVC Visualization for TemplateTypeParmType and TemplateTypeParmDecl llvm-svn: 350482
2019-01-06 07:15:30 +08:00
{*this, view(Dependent)}{*this, view(InstantiationDependent)}{*this, view(VariablyModified)}
{*this, view(ContainsUnexpandedParameterPack)}{*this, view(Cache)}{*this, view(FromAST)}</DisplayString>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<DisplayString>{*this,view(cmn)} {{{*this,view(poly)}}}</DisplayString>
<Expand>
<Item Name="TypeClass" IncludeView="cmn">(clang::Type::TypeClass)TypeBits.TC</Item>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<Item Name="Flags" IncludeView="cmn">this,view(flags)na</Item>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<Item Name="Canonical" IncludeView="cmn">CanonicalType</Item>
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::Builtin">*(clang::BuiltinType *)this</ExpandedItem>
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::Pointer">*(clang::PointerType *)this</ExpandedItem>
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::LValueReference">*(clang::LValueReferenceType *)this</ExpandedItem>
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::RValueReference">*(clang::RValueReferenceType *)this</ExpandedItem>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::ConstantArray">(clang::ConstantArrayType *)this</ExpandedItem>
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::IncompleteArray">(clang::IncompleteArrayType *)this</ExpandedItem>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::Attributed">*(clang::AttributedType *)this</ExpandedItem>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::Decayed">(clang::DecayedType *)this</ExpandedItem>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::TemplateTypeParm">(clang::TemplateTypeParmType *)this</ExpandedItem>
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::SubstTemplateTypeParm">(clang::SubstTemplateTypeParmType *)this</ExpandedItem>
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::Record">(clang::RecordType *)this</ExpandedItem>
Visual Studio Visualizer for clang::FunctionProtoType Displays return type and parameters for the Function Protoype object in the Locals window. llvm-svn: 263890
2016-03-20 08:20:43 +08:00
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::FunctionProto">(clang::FunctionProtoType *)this</ExpandedItem>
Visual Studio native visualizer for InjectedClassNameType Also fixes some omissions for TemplateSpecializationType llvm-svn: 264710
2016-03-29 17:24:45 +08:00
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::TemplateSpecialization">(clang::TemplateSpecializationType *)this</ExpandedItem>
Improve MSVC type visualizations Display TypeBits in a single line. Fix bit rot in template visualizations Rudimentary support for deduced types llvm-svn: 350470
2019-01-06 01:01:34 +08:00
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::DeducedTemplateSpecialization">(clang::DeducedTemplateSpecializationType *)this</ExpandedItem>
Visual Studio native visualizer for InjectedClassNameType Also fixes some omissions for TemplateSpecializationType llvm-svn: 264710
2016-03-29 17:24:45 +08:00
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::InjectedClassName">(clang::InjectedClassNameType *)this</ExpandedItem>
MSVC visualizers for type aliases For example, the following TypeAliasTemplateDecl now displays in the autos window as template<class T> using type_identity_t = type_identity<T>::type; llvm-svn: 364145
2019-06-23 09:15:48 +08:00
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::DependentName">(clang::DependentNameType *)this</ExpandedItem>
Visual Studio Visualizer for PackExpansionType llvm-svn: 272522
2016-06-13 06:54:46 +08:00
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::PackExpansion">(clang::PackExpansionType *)this</ExpandedItem>
Visual Studio Visualizers for ActionResult, LocInfoType, and and TypeSourceInfo Created a visualizer for ActionResult that displayed the validity and the pointer, but many of them initially displayed poorly. It turns out that the primary culprit is that LocInfoType is often passed in an action result, but it is not the same as other types. For example, LocInfoType is not in TypeNodes.def and clang::Type::TypeClass does not have a LocInfoType enum. After adding a special visualizer for LocInfoType, the display was more useful llvm-svn: 272487
2016-06-12 04:15:19 +08:00
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::LocInfoType::LocInfo">(clang::LocInfoType *)this</ExpandedItem>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
</Expand>
</Type>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<Type Name="clang::ArrayType">
<Expand>
<Item Name="ElementType">ElementType</Item>
</Expand>
</Type>
<Type Name="clang::ConstantArrayType">
<DisplayString IncludeView="left">{ElementType,view(cpp)}</DisplayString>
<DisplayString IncludeView="right">[{Size}]</DisplayString>
<DisplayString>{ElementType,view(cpp)}[{Size}]</DisplayString>
<Expand>
<Item Name="Size">Size</Item>
<ExpandedItem>(clang::ArrayType *)this</ExpandedItem>
</Expand>
</Type>
<Type Name="clang::IncompleteArrayType">
<DisplayString IncludeView="left">{ElementType,view(cpp)}</DisplayString>
<DisplayString IncludeView="right">[]</DisplayString>
<DisplayString>{ElementType,view(cpp)}[]</DisplayString>
<Expand>
<ExpandedItem>(clang::ArrayType *)this</ExpandedItem>
</Expand>
</Type>
MSVC visualizers for type aliases For example, the following TypeAliasTemplateDecl now displays in the autos window as template<class T> using type_identity_t = type_identity<T>::type; llvm-svn: 364145
2019-06-23 09:15:48 +08:00
<Type Name="clang::TypedefType">
<DisplayString IncludeView="cpp">{Decl,view(name)nd}</DisplayString>
<DisplayString>{Decl}</DisplayString>
<Expand>
<Item Name="Decl">Decl</Item>
<ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
</Expand>
</Type>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<Type Name="clang::PointerType">
Various tweaks to MSVC natvis visualizers Make more consistent use of na format. Improve visualization of deduction guides. Add visualizer for explicit specifier (including conditionally explicit) Fix some typos llvm-svn: 364724
2019-07-01 06:04:25 +08:00
<DisplayString>{PointeeType, view(cpp)} *</DisplayString>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<Expand>
<Item Name="PointeeType">PointeeType</Item>
Fix redundant "typename typename T" in Visual Studio Native Visualizer Also, a little minor cleanup llvm-svn: 265338
2016-04-05 03:36:48 +08:00
<ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
</Expand>
</Type>
<!-- We visualize all inner types for clang reference types. So a rvalue reference to an lvalue reference
to an int would visual as int &amp; &amp;&amp; This is a little different than GetPointeeType(),
but more clearly displays the data structure and seems natural -->
<Type Name="clang::LValueReferenceType">
<DisplayString>{((clang::ReferenceType *)this)-&gt;PointeeType,view(cpp)} &amp;</DisplayString>
<Expand>
<ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
<Item Name="PointeeType">PointeeType</Item>
</Expand>
</Type>
<Type Name="clang::RValueReferenceType">
<DisplayString>{((clang::ReferenceType *)this)-&gt;PointeeType,view(cpp)} &amp;&amp;</DisplayString>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Expand>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
<Item Name="PointeeType">PointeeType</Item>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
</Expand>
</Type>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<Type Name="clang::AttributedType">
<DisplayString>{ModifiedType} Attribute={(clang::AttributedType::Kind)AttributedTypeBits.AttrKind}</DisplayString>
</Type>
Show members of DeclContexts (i.e., class members) in Visual Studio native visualizers This change shows members of DeclContext objects in the Visual Studio debugger. It will also cast a TagType like a class or a struct to a DeclContext, so its methods and fields are visualized. llvm-svn: 263794
2016-03-19 00:38:34 +08:00
<!-- Unfortunately, Visual Studio has trouble seeing the PointerBitMask member PointerIntUnion, so I hardwire it to 2 bits-->
<Type Name="clang::DeclContext">
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString>{(clang::Decl::Kind)DeclContextBits.DeclKind,en}Decl</DisplayString>
Show members of DeclContexts (i.e., class members) in Visual Studio native visualizers This change shows members of DeclContext objects in the Visual Studio debugger. It will also cast a TagType like a class or a struct to a DeclContext, so its methods and fields are visualized. llvm-svn: 263794
2016-03-19 00:38:34 +08:00
<Expand>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<Item Name="DeclKind">(clang::Decl::Kind)DeclContextBits.DeclKind,en</Item>
Visual Studio Native Visualizations for constructors and methods With this change, the class struct A { A(int _i); ~A(); int foo(double d); double bar(A *a) { return 1.3; } }; appears in the VS2015 Locals Window as D 0x02dbb378 struct A |- DeclKind CXXRecord |- Members |- [0] implicit struct A |- [1] Constructor {A(int _i)} |- [2] Destructor {~A()} |- [3] Method {int foo(double d)} |- [4] Method {double bar(struct A *)} |- [Raw View] /* Other stuff */ Note that these changes only benefit VS2015 as VS2013 does not have views and only displays the struct name "A", but the change does no apparent harm in VS2013, so is still a win. llvm-svn: 264020
2016-03-22 10:29:22 +08:00
<Synthetic Name="Members">
<DisplayString></DisplayString>
<Expand>
<LinkedListItems>
<HeadPointer>FirstDecl</HeadPointer>
<NextPointer>(clang::Decl *)(NextInContextAndBits.Value &amp; ~3)</NextPointer>
<ValueNode>*this</ValueNode>
</LinkedListItems>
</Expand>
</Synthetic>
Show members of DeclContexts (i.e., class members) in Visual Studio native visualizers This change shows members of DeclContext objects in the Visual Studio debugger. It will also cast a TagType like a class or a struct to a DeclContext, so its methods and fields are visualized. llvm-svn: 263794
2016-03-19 00:38:34 +08:00
</Expand>
</Type>
<Type Name="clang::FieldDecl">
Visualize fields of records as they were declared in Visual Studio debugger llvm-svn: 264169
2016-03-24 01:29:42 +08:00
<DisplayString>Field {{{*(clang::DeclaratorDecl *)this,view(cpp)nd}}}</DisplayString>
Show members of DeclContexts (i.e., class members) in Visual Studio native visualizers This change shows members of DeclContext objects in the Visual Studio debugger. It will also cast a TagType like a class or a struct to a DeclContext, so its methods and fields are visualized. llvm-svn: 263794
2016-03-19 00:38:34 +08:00
</Type>
<Type Name="clang::CXXMethodDecl">
Visual Studio Native Visualizations for constructors and methods With this change, the class struct A { A(int _i); ~A(); int foo(double d); double bar(A *a) { return 1.3; } }; appears in the VS2015 Locals Window as D 0x02dbb378 struct A |- DeclKind CXXRecord |- Members |- [0] implicit struct A |- [1] Constructor {A(int _i)} |- [2] Destructor {~A()} |- [3] Method {int foo(double d)} |- [4] Method {double bar(struct A *)} |- [Raw View] /* Other stuff */ Note that these changes only benefit VS2015 as VS2013 does not have views and only displays the struct name "A", but the change does no apparent harm in VS2013, so is still a win. llvm-svn: 264020
2016-03-22 10:29:22 +08:00
<DisplayString IncludeView="cpp">{*(clang::FunctionDecl *)this,nd}</DisplayString>
<DisplayString>Method {{{*this,view(cpp)}}}</DisplayString>
Show members of DeclContexts (i.e., class members) in Visual Studio native visualizers This change shows members of DeclContext objects in the Visual Studio debugger. It will also cast a TagType like a class or a struct to a DeclContext, so its methods and fields are visualized. llvm-svn: 263794
2016-03-19 00:38:34 +08:00
</Type>
<Type Name="clang::CXXConstructorDecl">
Visual Studio Native Visualizations for constructors and methods With this change, the class struct A { A(int _i); ~A(); int foo(double d); double bar(A *a) { return 1.3; } }; appears in the VS2015 Locals Window as D 0x02dbb378 struct A |- DeclKind CXXRecord |- Members |- [0] implicit struct A |- [1] Constructor {A(int _i)} |- [2] Destructor {~A()} |- [3] Method {int foo(double d)} |- [4] Method {double bar(struct A *)} |- [Raw View] /* Other stuff */ Note that these changes only benefit VS2015 as VS2013 does not have views and only displays the struct name "A", but the change does no apparent harm in VS2013, so is still a win. llvm-svn: 264020
2016-03-22 10:29:22 +08:00
<DisplayString>Constructor {{{Name,view(cpp)}({*(clang::FunctionDecl *)this,view(parm0)nd})}}</DisplayString>
Show members of DeclContexts (i.e., class members) in Visual Studio native visualizers This change shows members of DeclContext objects in the Visual Studio debugger. It will also cast a TagType like a class or a struct to a DeclContext, so its methods and fields are visualized. llvm-svn: 263794
2016-03-19 00:38:34 +08:00
</Type>
<Type Name="clang::CXXDestructorDecl">
Visual Studio Native Visualizations for constructors and methods With this change, the class struct A { A(int _i); ~A(); int foo(double d); double bar(A *a) { return 1.3; } }; appears in the VS2015 Locals Window as D 0x02dbb378 struct A |- DeclKind CXXRecord |- Members |- [0] implicit struct A |- [1] Constructor {A(int _i)} |- [2] Destructor {~A()} |- [3] Method {int foo(double d)} |- [4] Method {double bar(struct A *)} |- [Raw View] /* Other stuff */ Note that these changes only benefit VS2015 as VS2013 does not have views and only displays the struct name "A", but the change does no apparent harm in VS2013, so is still a win. llvm-svn: 264020
2016-03-22 10:29:22 +08:00
<DisplayString>Destructor {{~{Name,view(cpp)}()}}</DisplayString>
Show members of DeclContexts (i.e., class members) in Visual Studio native visualizers This change shows members of DeclContext objects in the Visual Studio debugger. It will also cast a TagType like a class or a struct to a DeclContext, so its methods and fields are visualized. llvm-svn: 263794
2016-03-19 00:38:34 +08:00
</Type>
Visual Studio native visualization for TemplateParameterList and TemplateTypeParmDecl With this change, a TemplateParameterList will suggestively display in the locals window something like: <typename T, int i> llvm-svn: 264714
2016-03-29 18:57:24 +08:00
<Type Name="clang::TemplateTypeParmDecl">
Visualize ellipses in TemplateTypeParm and TemplateTypeParmDecl Now a TemplateTypeParm will be visualized as typename ...T if it is a pack llvm-svn: 270521
2016-05-24 09:47:41 +08:00
<DisplayString IncludeView="TorC" Condition="Typename">typename</DisplayString>
<DisplayString IncludeView="TorC" Condition="!Typename">class</DisplayString>
Fix MSVC Visualization for TemplateTypeParmType and TemplateTypeParmDecl llvm-svn: 350482
2019-01-06 07:15:30 +08:00
<DisplayString IncludeView="MaybeEllipses" Condition="TypeForDecl == nullptr">(not yet known if parameter pack) </DisplayString>
<DisplayString IncludeView="MaybeEllipses" Condition="((TemplateTypeParmType *)(((clang::ExtQualsTypeCommonBase *)(((uintptr_t)TypeForDecl->CanonicalType.Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType))->CanTTPTInfo.ParameterPack">...</DisplayString>
<DisplayString IncludeView="MaybeEllipses" Condition="!((TemplateTypeParmType *)(((clang::ExtQualsTypeCommonBase *)(((uintptr_t)TypeForDecl->CanonicalType.Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType))->CanTTPTInfo.ParameterPack"></DisplayString>
Template-related improvements to Visual Studio visualizers llvm-svn: 366007
2019-07-13 23:27:53 +08:00
<DisplayString IncludeView="DefaultArg" Condition="(DefaultArgument.ValueOrInherited.Val.Value&amp;3LL) == 0">{(TypeSourceInfo *)(DefaultArgument.ValueOrInherited.Val.Value&amp;~3LL),view(cpp)}</DisplayString>
<DisplayString IncludeView="DefaultArg">{{InheritedInitializer}}</DisplayString>
<DisplayString IncludeView="Initializer" Condition="DefaultArgument.ValueOrInherited.Val.Value&amp;~3LL">= {this,view(DefaultArg)na}</DisplayString>
<DisplayString IncludeView="Initializer"></DisplayString>
<DisplayString>{*this,view(TorC)} {*this,view(MaybeEllipses)}{Name,view(cpp)} {this,view(Initializer)na}</DisplayString>
Visual Studio native visualization for TemplateParameterList and TemplateTypeParmDecl With this change, a TemplateParameterList will suggestively display in the locals window something like: <typename T, int i> llvm-svn: 264714
2016-03-29 18:57:24 +08:00
</Type>
Visual Studio native visualization for clang::TemplateDecl With this change, TemplateDecls display in the Locals Window something like template<typename T, typename U> struct A; llvm-svn: 264997
2016-03-31 14:09:56 +08:00
<Type Name="clang::TemplateDecl">
Improve MSVC visualizers for DeclSpec and TemplateName DeclSpec now shows the TypeRep, ExprRep, or DeclRep as appropriate TemplateName decodes and displays the StorageType A few minor refinements to other types llvm-svn: 367199
2019-07-29 11:34:40 +08:00
<DisplayString IncludeView="cpp">{*TemplatedDecl,view(cpp)}</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString>template{TemplateParams,na} {*TemplatedDecl};</DisplayString>
<Expand>
<Item Name="TemplateParams">TemplateParams,na</Item>
<Item Name="TemplatedDecl">TemplatedDecl,na</Item>
</Expand>
Improve MSVC type visualizations Display TypeBits in a single line. Fix bit rot in template visualizations Rudimentary support for deduced types llvm-svn: 350470
2019-01-06 01:01:34 +08:00
</Type>
MSVC visualizers for type aliases For example, the following TypeAliasTemplateDecl now displays in the autos window as template<class T> using type_identity_t = type_identity<T>::type; llvm-svn: 364145
2019-06-23 09:15:48 +08:00
<!-- Unfortunately, visualization of PointerIntPair<PointerUnion> doesn't work due to limitations in natvis, so we will barehad it-->
<Type Name="clang::TypedefNameDecl">
<DisplayString Condition="(MaybeModedTInfo.Value &amp; 4)==0" IncludeView="type">{(clang::TypeSourceInfo *)(MaybeModedTInfo.Value &amp; ~7LL),view(cpp)na}</DisplayString>
<DisplayString Condition="(MaybeModedTInfo.Value &amp; 4)!=0" IncludeView="type">{(clang::TypedefNameDecl::ModedTInfo *)(MaybeModedTInfo.Value &amp; ~7LL),view(cpp)na}</DisplayString>
<DisplayString IncludeView="name">{(TypeDecl *)this,view(cpp)nand}</DisplayString>
Various tweaks to MSVC natvis visualizers Make more consistent use of na format. Improve visualization of deduction guides. Add visualizer for explicit specifier (including conditionally explicit) Fix some typos llvm-svn: 364724
2019-07-01 06:04:25 +08:00
<DisplayString>typedef {this,view(type)na} {this,view(name)na};</DisplayString>
MSVC visualizers for type aliases For example, the following TypeAliasTemplateDecl now displays in the autos window as template<class T> using type_identity_t = type_identity<T>::type; llvm-svn: 364145
2019-06-23 09:15:48 +08:00
<Expand>
<Item Name="IsTransparent" Condition="(MaybeModedTInfo.Value &amp; 1)==0">"Not yet calculated",sb</Item>
<Item Name="IsTransparent" Condition="(MaybeModedTInfo.Value &amp; 1)!=0">(bool)(MaybeModedTInfo.Value &amp; 2)</Item>
<Item Name="TypeSourceInfo" Condition="(MaybeModedTInfo.Value &amp; 4)==0">(clang::TypeSourceInfo *)(MaybeModedTInfo.Value &amp; ~7LL)</Item>
<Item Name="ModedTInfo" Condition="(MaybeModedTInfo.Value &amp; 4)!=0">(clang::TypedefNameDecl::ModedTInfo *)(MaybeModedTInfo.Value &amp; ~7LL)</Item>
<ExpandedItem>(TypeDecl *)this,nd</ExpandedItem>
</Expand>
</Type>
<Type Name="clang::TypeAliasDecl">
Various tweaks to MSVC natvis visualizers Make more consistent use of na format. Improve visualization of deduction guides. Add visualizer for explicit specifier (including conditionally explicit) Fix some typos llvm-svn: 364724
2019-07-01 06:04:25 +08:00
<DisplayString IncludeView="cpp">{(TypedefNameDecl *)this,view(name)nand}</DisplayString>
MSVC visualizers for type aliases For example, the following TypeAliasTemplateDecl now displays in the autos window as template<class T> using type_identity_t = type_identity<T>::type; llvm-svn: 364145
2019-06-23 09:15:48 +08:00
<DisplayString>using {(TypedefNameDecl *)this,view(name)nand} = {(TypedefNameDecl *)this,view(type)nand}</DisplayString>
</Type>
Improve MSVC visualization of annot_template_id tokens Now shows the actual annotated template. E.g., {annot_template_id (A<int, double>)} Also a few miscellaneous fixes to visualizers of other types llvm-svn: 365248
2019-07-06 05:41:30 +08:00
<Type Name="clang::AssumedTemplateStorage">
<DisplayString>{Name}</DisplayString>
</Type>
<Type Name="clang::UncommonTemplateNameStorage::BitsTag">
<DisplayString>Kind={(UncommonTemplateNameStorage::Kind)Kind,en}, Size={Size}</DisplayString>
<Expand>
<Item Name="Kind">(UncommonTemplateNameStorage::Kind)Kind</Item>
<Item Name="Size">Size</Item>
</Expand>
</Type>
<Type Name="clang::UncommonTemplateNameStorage">
<DisplayString IncludeView="cmn">{Bits},</DisplayString>
<DisplayString Condition="Bits.Kind==UncommonTemplateNameStorage::Overloaded">{this,view(cmn)na},{(OverloadedTemplateStorage*)this,na}</DisplayString>
<DisplayString Condition="Bits.Kind==UncommonTemplateNameStorage::Assumed">{this,view(cmn)na},{(AssumedTemplateStorage*)this,na}</DisplayString>
<DisplayString Condition="Bits.Kind==UncommonTemplateNameStorage::SubstTemplateTemplateParm">{this,view(cmn)na},{(SubstTemplateTemplateParmStorage*)this,na}</DisplayString>
<DisplayString Condition="Bits.Kind==UncommonTemplateNameStorage::SubstTemplateTemplateParmPack">{this,view(cmn)na},{(SubstTemplateTemplateParmPackStorage*)this,na}</DisplayString>
<DisplayString>{this,view(cmn)na}</DisplayString>
<Expand>
<Item Name="Bits">Bits</Item>
<ExpandedItem Condition="Bits.Kind==UncommonTemplateNameStorage::Overloaded">(OverloadedTemplateStorage*)this</ExpandedItem>
<ExpandedItem Condition="Bits.Kind==UncommonTemplateNameStorage::Assumed">(AssumedTemplateStorage*)this</ExpandedItem>
<ExpandedItem Condition="Bits.Kind==UncommonTemplateNameStorage::SubstTemplateTemplateParm">(SubstTemplateTemplateParmStorage*)this</ExpandedItem>
<ExpandedItem Condition="Bits.Kind==UncommonTemplateNameStorage::SubstTemplateTemplateParmPack">(SubstTemplateTemplateParmPackStorage*)this</ExpandedItem>
</Expand>
</Type>
Improve MSVC visualizers for DeclSpec and TemplateName DeclSpec now shows the TypeRep, ExprRep, or DeclRep as appropriate TemplateName decodes and displays the StorageType A few minor refinements to other types llvm-svn: 367199
2019-07-29 11:34:40 +08:00
<!-- clang::TemplateName::StorageType -->
<Type Name="llvm::PointerUnion&lt;clang::TemplateDecl *, clang::UncommonTemplateNameStorage *,
clang::QualifiedTemplateName *, clang::DependentTemplateName *&gt;">
<!-- Expand this out by hand to get cpp view -->
<DisplayString Condition="(Val.Value &amp;3) == 0" IncludeView="cpp">
{(clang::TemplateDecl *)(Val.Value &amp; ~3LL),view(cpp)na}
</DisplayString>
<DisplayString Condition="(Val.Value &amp;3) == 0">
{(clang::TemplateDecl *)(Val.Value &amp; ~3LL),na}
</DisplayString>
<DisplayString Condition="(Val.Value &amp;3) == 1" IncludeView="cpp">
{(clang::UncommonTemplateNameStorage *)(Val.Value &amp; ~3LL),view(cpp)na}
</DisplayString>
<DisplayString Condition="(Val.Value &amp;3) == 1">
{(clang::UncommonTemplateNameStorage *)(Val.Value &amp; ~3LL),na}
</DisplayString>
<DisplayString Condition="(Val.Value &amp;3) == 2" IncludeView="cpp">
{(clang::QualifiedTemplateName *)(Val.Value &amp; ~3LL),view(cpp)na}
</DisplayString>
<DisplayString Condition="(Val.Value &amp;3) == 2">
{(clang::QualifiedTemplateName *)(Val.Value &amp; ~3LL),na}
</DisplayString>
<DisplayString Condition="(Val.Value &amp;3) == 3" IncludeView="cpp">
{(clang::DependentTemplateName *)(Val.Value &amp; ~3LL),view(cpp)na}
</DisplayString>
<DisplayString Condition="(Val.Value &amp;3) == 3">
{(clang::DependentTemplateName *)(Val.Value &amp; ~3LL),na}
</DisplayString>
<Expand>
<Item Name="[Holds]" Condition="(Val.Value &amp;3) == 0">"TemplateDecl",s8b</Item>
<Item Name="[Ptr]" Optional="true" Condition="(Val.Value &amp;3) == 0">
(clang::TemplateDecl *)(Val.Value &amp; ~3LL)
</Item>
<Item Name="[Holds]" Condition="(Val.Value &amp;3) == 1">"UncommonTemplateNameStorage",s8b</Item>
<Item Name="[Ptr]" Optional="true" Condition="(Val.Value &amp;3) == 1">
(clang::UncommonTemplateNameStorage *)(Val.Value &amp; ~3LL)
</Item>
<Item Name="[Holds]" Condition="(Val.Value &amp;3) == 2">"QualifiedTemplateName",s8b</Item>
<Item Name="[Ptr]" Optional="true" Condition="(Val.Value &amp;3) == 2">
(clang::QualifiedTemplateName *)(Val.Value &amp; ~3LL)
</Item>
<Item Name="[Holds]" Condition="(Val.Value &amp;3) == 3">"DependentTemplateName",s8b</Item>
<Item Name="[Ptr]" Optional="true" Condition="(Val.Value &amp;3) == 3">
(clang::DependentTemplateName *)(Val.Value &amp; ~3LL)
</Item>
<Item Name="[Val]">Val</Item>
</Expand>
</Type>
Improve MSVC type visualizations Display TypeBits in a single line. Fix bit rot in template visualizations Rudimentary support for deduced types llvm-svn: 350470
2019-01-06 01:01:34 +08:00
<Type Name="clang::TemplateName">
Improve MSVC visualizers for DeclSpec and TemplateName DeclSpec now shows the TypeRep, ExprRep, or DeclRep as appropriate TemplateName decodes and displays the StorageType A few minor refinements to other types llvm-svn: 367199
2019-07-29 11:34:40 +08:00
<DisplayString IncludeView="cpp">{Storage,view(cpp)na}</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString>{Storage,na}</DisplayString>
Improve MSVC type visualizations Display TypeBits in a single line. Fix bit rot in template visualizations Rudimentary support for deduced types llvm-svn: 350470
2019-01-06 01:01:34 +08:00
<Expand>
<ExpandedItem>Storage</ExpandedItem>
</Expand>
Visual Studio native visualization for clang::TemplateDecl With this change, TemplateDecls display in the Locals Window something like template<typename T, typename U> struct A; llvm-svn: 264997
2016-03-31 14:09:56 +08:00
</Type>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<Type Name="clang::NamedDecl" >
<DisplayString IncludeView="cpp">{Name,view(cpp)}</DisplayString>
<DisplayString>{Name}</DisplayString>
</Type>
<Type Name="clang::TagDecl">
Visual Studio Native Visualizations for constructors and methods With this change, the class struct A { A(int _i); ~A(); int foo(double d); double bar(A *a) { return 1.3; } }; appears in the VS2015 Locals Window as D 0x02dbb378 struct A |- DeclKind CXXRecord |- Members |- [0] implicit struct A |- [1] Constructor {A(int _i)} |- [2] Destructor {~A()} |- [3] Method {int foo(double d)} |- [4] Method {double bar(struct A *)} |- [Raw View] /* Other stuff */ Note that these changes only benefit VS2015 as VS2013 does not have views and only displays the struct name "A", but the change does no apparent harm in VS2013, so is still a win. llvm-svn: 264020
2016-03-22 10:29:22 +08:00
<DisplayString IncludeView="implicit" Condition="Implicit">implicit{" ",sb}</DisplayString>
<DisplayString IncludeView="implicit"></DisplayString>
Have MSVC Visualizer for DeducedTemplateSpecializationType show both the original template and deduced specialization Now appears in the Autos window something like - MyType DeducedTemplateSpecializationType {struct Y<int>} |- Template template<typename T> struct Y; |- Deduced As struct Y<int> |- isDeduced true bool |- TypeClass DeducedTemplateSpecialization (36) |- Flags No TypeBits set beyond TypeClass |- Canonical RecordType {struct Y<int>} Also changed QualType visualization to auto-expand the BaseType llvm-svn: 350487
2019-01-06 12:58:48 +08:00
<DisplayString IncludeView="modifiers">{*this,view(implicit)nd}</DisplayString>
Visual Studio Native Visualizations for constructors and methods With this change, the class struct A { A(int _i); ~A(); int foo(double d); double bar(A *a) { return 1.3; } }; appears in the VS2015 Locals Window as D 0x02dbb378 struct A |- DeclKind CXXRecord |- Members |- [0] implicit struct A |- [1] Constructor {A(int _i)} |- [2] Destructor {~A()} |- [3] Method {int foo(double d)} |- [4] Method {double bar(struct A *)} |- [Raw View] /* Other stuff */ Note that these changes only benefit VS2015 as VS2013 does not have views and only displays the struct name "A", but the change does no apparent harm in VS2013, so is still a win. llvm-svn: 264020
2016-03-22 10:29:22 +08:00
<DisplayString IncludeView="cpp">{*this,view(modifiers)}{Name,view(cpp)}</DisplayString>
Have MSVC Visualizer for DeducedTemplateSpecializationType show both the original template and deduced specialization Now appears in the Autos window something like - MyType DeducedTemplateSpecializationType {struct Y<int>} |- Template template<typename T> struct Y; |- Deduced As struct Y<int> |- isDeduced true bool |- TypeClass DeducedTemplateSpecialization (36) |- Flags No TypeBits set beyond TypeClass |- Canonical RecordType {struct Y<int>} Also changed QualType visualization to auto-expand the BaseType llvm-svn: 350487
2019-01-06 12:58:48 +08:00
<DisplayString Condition="TagDeclBits.TagDeclKind==clang::TagTypeKind::TTK_Struct">{*this,view(modifiers)nd}struct {Name,view(cpp)}</DisplayString>
<DisplayString Condition="TagDeclBits.TagDeclKind==clang::TagTypeKind::TTK_Interface">{*this,view(modifiers)nd}interface {Name,view(cpp)}</DisplayString>
<DisplayString Condition="TagDeclBits.TagDeclKind==clang::TagTypeKind::TTK_Union">{*this,view(modifiers)nd}union {Name,view(cpp)}</DisplayString>
<DisplayString Condition="TagDeclBits.TagDeclKind==clang::TagTypeKind::TTK_Class">{*this,view(modifiers)nd}class {Name,view(cpp)}</DisplayString>
<DisplayString Condition="TagDeclBits.TagDeclKind==clang::TagTypeKind::TTK_Enum">{*this,view(modifiers)nd}enum {Name,view(cpp)}</DisplayString>
Show members of DeclContexts (i.e., class members) in Visual Studio native visualizers This change shows members of DeclContext objects in the Visual Studio debugger. It will also cast a TagType like a class or a struct to a DeclContext, so its methods and fields are visualized. llvm-svn: 263794
2016-03-19 00:38:34 +08:00
<Expand>
<ExpandedItem>(clang::DeclContext *)this</ExpandedItem>
</Expand>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
</Type>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Type Name="clang::TagType">
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="cpp">{decl,view(cpp)na}</DisplayString>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<DisplayString>{*decl}</DisplayString>
<Expand>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Item Name="decl">decl</Item>
</Expand>
</Type>
<Type Name="clang::RecordType">
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="cpp">{(clang::TagType *)this,view(cpp)na}</DisplayString>
<DisplayString>{(clang::TagType *)this,na}</DisplayString>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Expand>
<Item Name="TagType">*(clang::TagType *)this</Item>
</Expand>
</Type>
<Type Name="clang::SubstTemplateTypeParmType">
Template-related improvements to Visual Studio visualizers llvm-svn: 366007
2019-07-13 23:27:53 +08:00
<DisplayString>{{{*Replaced,view(cpp)} &lt;= {CanonicalType,view(cpp)}}}</DisplayString>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Expand>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Item Name="Replaced">*Replaced</Item>
</Expand>
</Type>
Visual Studio Visualizer for clang::FunctionProtoType Displays return type and parameters for the Function Protoype object in the Locals window. llvm-svn: 263890
2016-03-20 08:20:43 +08:00
<!-- We only show the first 5 parameter types in the display string (can't figure out how to loop in DisplayString)
but the expansion has all parameters -->
<Type Name="clang::FunctionProtoType">
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="left" Condition="FunctionTypeBits.HasTrailingReturn"></DisplayString>
<DisplayString IncludeView="left">{ResultType,view(cpp)}</DisplayString>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<DisplayString IncludeView="parm0" Condition="FunctionTypeBits.NumParams==0"></DisplayString>
Visual Studio Visualizer for clang::FunctionProtoType Displays return type and parameters for the Function Protoype object in the Locals window. llvm-svn: 263890
2016-03-20 08:20:43 +08:00
<DisplayString IncludeView="parm0">{*(clang::QualType *)(this+1),view(cpp)}{*this,view(parm1)}</DisplayString>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<DisplayString IncludeView="parm1" Condition="FunctionTypeBits.NumParams==1"></DisplayString>
Visual Studio Visualizer for clang::FunctionProtoType Displays return type and parameters for the Function Protoype object in the Locals window. llvm-svn: 263890
2016-03-20 08:20:43 +08:00
<DisplayString IncludeView="parm1">, {*((clang::QualType *)(this+1)+1),view(cpp)}{*this,view(parm2)}</DisplayString>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<DisplayString IncludeView="parm2" Condition="FunctionTypeBits.NumParams==2"></DisplayString>
Visual Studio Visualizer for clang::FunctionProtoType Displays return type and parameters for the Function Protoype object in the Locals window. llvm-svn: 263890
2016-03-20 08:20:43 +08:00
<DisplayString IncludeView="parm2">, {*((clang::QualType *)(this+1)+2),view(cpp)}{*this,view(parm3)}</DisplayString>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<DisplayString IncludeView="parm3" Condition="FunctionTypeBits.NumParams==3"></DisplayString>
Visual Studio Visualizer for clang::FunctionProtoType Displays return type and parameters for the Function Protoype object in the Locals window. llvm-svn: 263890
2016-03-20 08:20:43 +08:00
<DisplayString IncludeView="parm3">, {*((clang::QualType *)(this+1)+3),view(cpp)}{*this,view(parm4)}</DisplayString>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<DisplayString IncludeView="parm4" Condition="FunctionTypeBits.NumParams==4"></DisplayString>
Visual Studio Visualizer for clang::FunctionProtoType Displays return type and parameters for the Function Protoype object in the Locals window. llvm-svn: 263890
2016-03-20 08:20:43 +08:00
<DisplayString IncludeView="parm4">, {*((clang::QualType *)(this+1)+4),view(cpp)}{*this,view(parm5)}</DisplayString>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<DisplayString IncludeView="parm5" Condition="FunctionTypeBits.NumParams==5"></DisplayString>
Visual Studio Visualizer for clang::FunctionProtoType Displays return type and parameters for the Function Protoype object in the Locals window. llvm-svn: 263890
2016-03-20 08:20:43 +08:00
<DisplayString IncludeView="parm5">, /* expand for more params */</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="right" Condition="FunctionTypeBits.HasTrailingReturn">({*this,view(parm0)}) -&gt; {ResultType,view(cpp)}</DisplayString>
<DisplayString IncludeView="right">({*this,view(parm0)})</DisplayString>
<DisplayString>{this,view(left)na}{this,view(right)na}</DisplayString>
Visual Studio Visualizer for clang::FunctionProtoType Displays return type and parameters for the Function Protoype object in the Locals window. llvm-svn: 263890
2016-03-20 08:20:43 +08:00
<Expand>
Improve MSVC visualization of annot_template_id tokens Now shows the actual annotated template. E.g., {annot_template_id (A<int, double>)} Also a few miscellaneous fixes to visualizers of other types llvm-svn: 365248
2019-07-06 05:41:30 +08:00
<Item Name="ResultType">ResultType</Item>
Visual Studio Visualizer for clang::FunctionProtoType Displays return type and parameters for the Function Protoype object in the Locals window. llvm-svn: 263890
2016-03-20 08:20:43 +08:00
<Synthetic Name="Parameter Types">
<DisplayString>{*this,view(parm0)}</DisplayString>
<Expand>
<ArrayItems>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<Size>FunctionTypeBits.NumParams</Size>
Visual Studio Visualizer for clang::FunctionProtoType Displays return type and parameters for the Function Protoype object in the Locals window. llvm-svn: 263890
2016-03-20 08:20:43 +08:00
<ValuePointer>(clang::QualType *)(this+1)</ValuePointer>
</ArrayItems>
</Expand>
</Synthetic>
<ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
</Expand>
</Type>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<Type Name="clang::AdjustedType">
<DisplayString>{OriginalTy} adjusted to {AdjustedTy}</DisplayString>
<Expand>
<Item Name="OriginalTy">OriginalTy</Item>
<Item Name="AdjustedTy">AdjustedTy</Item>
</Expand>
</Type>
<Type Name="clang::DecayedType">
<DisplayString IncludeView="left">{OriginalTy,view(left)}</DisplayString>
<DisplayString IncludeView="right">{OriginalTy,view(right)}</DisplayString>
<DisplayString>{OriginalTy}</DisplayString>
<Expand>
<ExpandedItem>(clang::AdjustedType *)this</ExpandedItem>
</Expand>
</Type>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Type Name="clang::TemplateTypeParmType">
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="cpp" Condition="CanonicalType.Value.Value != this">{TTPDecl->Name,view(cpp)}</DisplayString>
Fix MSVC Visualization for TemplateTypeParmType and TemplateTypeParmDecl llvm-svn: 350482
2019-01-06 07:15:30 +08:00
<DisplayString Condition="CanonicalType.Value.Value != this">Non-canonical: {*TTPDecl}</DisplayString>
<DisplayString>Canonical: {CanTTPTInfo}</DisplayString>
<Expand>
Improve MSVC visualization of annot_template_id tokens Now shows the actual annotated template. E.g., {annot_template_id (A<int, double>)} Also a few miscellaneous fixes to visualizers of other types llvm-svn: 365248
2019-07-06 05:41:30 +08:00
<ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
Fix MSVC Visualization for TemplateTypeParmType and TemplateTypeParmDecl llvm-svn: 350482
2019-01-06 07:15:30 +08:00
</Expand>
Added MSVC natvis visualizers for Type and QualType. These could probably be improved, but anything is better than staring at hex values in the debugger. llvm-svn: 248808
2015-09-30 01:32:36 +08:00
</Type>
Visual Studio native visualizer for InjectedClassNameType Also fixes some omissions for TemplateSpecializationType llvm-svn: 264710
2016-03-29 17:24:45 +08:00
<Type Name="clang::InjectedClassNameType">
Template-related improvements to Visual Studio visualizers llvm-svn: 366007
2019-07-13 23:27:53 +08:00
<DisplayString>{Decl,view(cpp)}</DisplayString>
Visual Studio native visualizer for InjectedClassNameType Also fixes some omissions for TemplateSpecializationType llvm-svn: 264710
2016-03-29 17:24:45 +08:00
<Expand>
<Item Name="Decl">Decl</Item>
<Item Name="InjectedType">InjectedType</Item>
<ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
</Expand>
</Type>
MSVC visualizers for type aliases For example, the following TypeAliasTemplateDecl now displays in the autos window as template<class T> using type_identity_t = type_identity<T>::type; llvm-svn: 364145
2019-06-23 09:15:48 +08:00
<Type Name="clang::DependentNameType">
<DisplayString>{NNS}{Name,view(cpp)na}</DisplayString>
<Expand>
<Item Name="NNS">NNS</Item>
<Item Name="Name">Name</Item>
<ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
</Expand>
</Type>
<Type Name="clang::NestedNameSpecifier">
<DisplayString Condition="!Specifier"></DisplayString>
<DisplayString Condition="((Prefix.Value&gt;&gt;1)&amp;3) == 0">{(IdentifierInfo*)Specifier,view(cpp)na}::</DisplayString>
<DisplayString Condition="((Prefix.Value&gt;&gt;1)&amp;3) == 1">{(NamedDecl*)Specifier,view(cpp)na}::</DisplayString>
<DisplayString Condition="((Prefix.Value&gt;&gt;1)&amp;2) == 2">{(Type*)Specifier,view(cpp)na}::</DisplayString>
<Expand>
<Item Name="Kind">(NestedNameSpecifier::StoredSpecifierKind)((Prefix.Value&gt;&gt;1)&amp;3)</Item>
</Expand>
</Type>
Visual Studio Visualizer for PackExpansionType llvm-svn: 272522
2016-06-13 06:54:46 +08:00
<Type Name="clang::PackExpansionType">
<DisplayString>{Pattern}</DisplayString>
<Expand>
<Item Name="Pattern">Pattern</Item>
<Item Name="NumExpansions">NumExpansions</Item>
<ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
</Expand>
</Type>
Added MSVC natvis visualizers for Type and QualType. These could probably be improved, but anything is better than staring at hex values in the debugger. llvm-svn: 248808
2015-09-30 01:32:36 +08:00
<Type Name="clang::QualType">
Display const/volatile/restrict qualifiers in Visual Studio visualizations llvm-svn: 264229
2016-03-24 08:38:54 +08:00
<!-- When VS2013 support is deprecated, change 4 to clang::TypeAlignmentInBits (not properly recognized by VS2013) -->
<DisplayString IncludeView="poly">{*((clang::ExtQualsTypeCommonBase *)(((uintptr_t)Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType,view(poly)}{*this,view(fastQuals)}</DisplayString>
<DisplayString IncludeView="cpp">{*((clang::ExtQualsTypeCommonBase *)(((uintptr_t)Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType,view(cpp)}{*this,view(fastQuals)}</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="left">{*((clang::ExtQualsTypeCommonBase *)(((uintptr_t)Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType,view(left)}{*this,view(fastQuals)}</DisplayString>
<DisplayString IncludeView="right">{*((clang::ExtQualsTypeCommonBase *)(((uintptr_t)Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType,view(right)}{*this,view(fastQuals)}</DisplayString>
Display const/volatile/restrict qualifiers in Visual Studio visualizations llvm-svn: 264229
2016-03-24 08:38:54 +08:00
<!-- For the Fast Qualifiers, it is simpler (and probably more efficient) just to list all 8 cases than create
views for each qualifier. TODO: Non-fast qualifiers -->
<DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==0"></DisplayString>
<DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==1">{" ",sb}const</DisplayString>
<DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==2">{" ",sb}restrict</DisplayString>
<DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==3">{" ",sb}const restrict</DisplayString>
<DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==4">{" ",sb}volatile</DisplayString>
<DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==5">{" ",sb}const volatile</DisplayString>
<DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==6">{" ",sb}volatile restrict</DisplayString>
<DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==7">{" ",sb}const volatile restrict</DisplayString>
<DisplayString IncludeView="fastQuals">Cannot visualize non-fast qualifiers</DisplayString>
Fix MSVC Visualization for TemplateTypeParmType and TemplateTypeParmDecl llvm-svn: 350482
2019-01-06 07:15:30 +08:00
<DisplayString Condition="(uintptr_t)Value.Value == 0">Null</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString>{((clang::ExtQualsTypeCommonBase *)(((uintptr_t)Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType,na}{*this,view(fastQuals)}</DisplayString>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Expand>
Display const/volatile/restrict qualifiers in Visual Studio visualizations llvm-svn: 264229
2016-03-24 08:38:54 +08:00
<Item Name="Fast Quals">*this,view(fastQuals)</Item>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<ExpandedItem>((clang::ExtQualsTypeCommonBase *)(((uintptr_t)Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType</ExpandedItem>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
</Expand>
</Type>
Visual Studio Visualizers for ActionResult, LocInfoType, and and TypeSourceInfo Created a visualizer for ActionResult that displayed the validity and the pointer, but many of them initially displayed poorly. It turns out that the primary culprit is that LocInfoType is often passed in an action result, but it is not the same as other types. For example, LocInfoType is not in TypeNodes.def and clang::Type::TypeClass does not have a LocInfoType enum. After adding a special visualizer for LocInfoType, the display was more useful llvm-svn: 272487
2016-06-12 04:15:19 +08:00
<Type Name="clang::LocInfoType">
Improve MSVC visualization of annot_template_id tokens Now shows the actual annotated template. E.g., {annot_template_id (A<int, double>)} Also a few miscellaneous fixes to visualizers of other types llvm-svn: 365248
2019-07-06 05:41:30 +08:00
<DisplayString IncludeView="cpp">{DeclInfo,view(cpp)na}</DisplayString>
<DisplayString>{DeclInfo,na}</DisplayString>
Visual Studio Visualizers for ActionResult, LocInfoType, and and TypeSourceInfo Created a visualizer for ActionResult that displayed the validity and the pointer, but many of them initially displayed poorly. It turns out that the primary culprit is that LocInfoType is often passed in an action result, but it is not the same as other types. For example, LocInfoType is not in TypeNodes.def and clang::Type::TypeClass does not have a LocInfoType enum. After adding a special visualizer for LocInfoType, the display was more useful llvm-svn: 272487
2016-06-12 04:15:19 +08:00
<Expand>
<Item Name="DeclInfo">DeclInfo</Item>
<ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
</Expand>
</Type>
<Type Name="clang::TypeSourceInfo">
MSVC visualizers for type aliases For example, the following TypeAliasTemplateDecl now displays in the autos window as template<class T> using type_identity_t = type_identity<T>::type; llvm-svn: 364145
2019-06-23 09:15:48 +08:00
<DisplayString IncludeView="cpp">{Ty,view(cpp)}</DisplayString>
Visual Studio Visualizers for ActionResult, LocInfoType, and and TypeSourceInfo Created a visualizer for ActionResult that displayed the validity and the pointer, but many of them initially displayed poorly. It turns out that the primary culprit is that LocInfoType is often passed in an action result, but it is not the same as other types. For example, LocInfoType is not in TypeNodes.def and clang::Type::TypeClass does not have a LocInfoType enum. After adding a special visualizer for LocInfoType, the display was more useful llvm-svn: 272487
2016-06-12 04:15:19 +08:00
<DisplayString>{Ty}</DisplayString>
MSVC visualizers for type aliases For example, the following TypeAliasTemplateDecl now displays in the autos window as template<class T> using type_identity_t = type_identity<T>::type; llvm-svn: 364145
2019-06-23 09:15:48 +08:00
<Expand>
<ExpandedItem>Ty</ExpandedItem>
</Expand>
Visual Studio Visualizers for ActionResult, LocInfoType, and and TypeSourceInfo Created a visualizer for ActionResult that displayed the validity and the pointer, but many of them initially displayed poorly. It turns out that the primary culprit is that LocInfoType is often passed in an action result, but it is not the same as other types. For example, LocInfoType is not in TypeNodes.def and clang::Type::TypeClass does not have a LocInfoType enum. After adding a special visualizer for LocInfoType, the display was more useful llvm-svn: 272487
2016-06-12 04:15:19 +08:00
</Type>
Template-related improvements to Visual Studio visualizers llvm-svn: 366007
2019-07-13 23:27:53 +08:00
<Type Name="clang::TypeLoc">
<DisplayString>{(QualType *)&amp;Ty,na}</DisplayString>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Expand>
Template-related improvements to Visual Studio visualizers llvm-svn: 366007
2019-07-13 23:27:53 +08:00
<Item Name="Ty">(QualType *)&amp;Ty</Item>
<Item Name="Data">Data</Item>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
</Expand>
</Type>
Template-related improvements to Visual Studio visualizers llvm-svn: 366007
2019-07-13 23:27:53 +08:00
<Type Name="clang::TypeLocBuilder">
<DisplayString Optional="true" Condition="LastTy.Value.Value==0">Not building anything</DisplayString>
<DisplayString Optional="true">Building a {LastTy}</DisplayString>
</Type>
<Type Name="clang::TemplateArgumentLoc">
<DisplayString IncludeView="cpp">{Argument,view(cpp)}</DisplayString>
<DisplayString>{Argument}</DisplayString>
</Type>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Type Name="clang::TemplateArgument">
Better Visual Studio visualization of TemplateArgument and TemplateArgumentList For pack TemplateArguments, visualize all of the items in the pack Visualize a TemplateArgumentList as a template argument list. E.g., <int, double> llvm-svn: 271910
2016-06-07 01:08:32 +08:00
<DisplayString IncludeView="cpp" Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Type">{*(clang::QualType *)&amp;TypeOrValue.V,view(cpp)}</DisplayString>
<DisplayString Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Type">{(clang::TemplateArgument::ArgKind)TypeOrValue.Kind,en} template argument: {*(clang::QualType *)&amp;TypeOrValue.V}</DisplayString>
<DisplayString IncludeView="arg0" Condition="Args.NumArgs==0"></DisplayString>
<DisplayString IncludeView="arg0">{Args.Args[0]}{*this,view(arg1)}</DisplayString>
<DisplayString IncludeView="arg1" Condition="Args.NumArgs==1"></DisplayString>
<DisplayString IncludeView="arg1">, {Args.Args[1]}{*this,view(arg2)}</DisplayString>
<DisplayString IncludeView="arg2" Condition="Args.NumArgs==2"></DisplayString>
<DisplayString IncludeView="arg2">, {Args.Args[2]}, ...</DisplayString>
<DisplayString IncludeView="arg0cpp" Condition="Args.NumArgs==0"></DisplayString>
<DisplayString IncludeView="arg0cpp">{Args.Args[0],view(cpp)}{*this,view(arg1cpp)}</DisplayString>
<DisplayString IncludeView="arg1cpp" Condition="Args.NumArgs==1"></DisplayString>
<DisplayString IncludeView="arg1cpp">, {Args.Args[1],view(cpp)}{*this,view(arg2cpp)}</DisplayString>
<DisplayString IncludeView="arg2cpp" Condition="Args.NumArgs==2"></DisplayString>
<DisplayString IncludeView="arg2cpp">, {Args.Args[2],view(cpp)}, ...</DisplayString>
<DisplayString IncludeView="cpp" Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Pack">{*this,view(arg0cpp)}</DisplayString>
<DisplayString Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Pack">{*this,view(arg0)}</DisplayString>
Improve MSVC visualization of annot_template_id tokens Now shows the actual annotated template. E.g., {annot_template_id (A<int, double>)} Also a few miscellaneous fixes to visualizers of other types llvm-svn: 365248
2019-07-06 05:41:30 +08:00
<DisplayString Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Expression">{(clang::Expr *)TypeOrValue.V,view(cpp)na}</DisplayString>
Visualizer for Pack template arguments llvm-svn: 270505
2016-05-24 06:27:44 +08:00
<DisplayString>{(clang::TemplateArgument::ArgKind)TypeOrValue.Kind,en}</DisplayString>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Expand>
<Item Name="QualType" Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Type">*(clang::QualType *)&amp;TypeOrValue.V</Item>
Improve MSVC visualization of annot_template_id tokens Now shows the actual annotated template. E.g., {annot_template_id (A<int, double>)} Also a few miscellaneous fixes to visualizers of other types llvm-svn: 365248
2019-07-06 05:41:30 +08:00
<Item Name="Expression" Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Expression">(clang::Expr *)TypeOrValue.V</Item>
Visualizer for Pack template arguments llvm-svn: 270505
2016-05-24 06:27:44 +08:00
<ArrayItems Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Pack">
<Size>Args.NumArgs</Size>
<ValuePointer>Args.Args</ValuePointer>
</ArrayItems>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<!-- TODO: Other kinds-->
</Expand>
</Type>
Template-related improvements to Visual Studio visualizers llvm-svn: 366007
2019-07-13 23:27:53 +08:00
<Type Name="clang::TemplateArgumentListInfo">
<DisplayString IncludeView ="elt0" Condition="Arguments.Size == 0"></DisplayString>
<DisplayString IncludeView ="elt0">{((TemplateArgumentLoc*)Arguments.BeginX)[0],view(cpp)}{*this,view(elt1)}</DisplayString>
<DisplayString IncludeView ="elt1" Condition="Arguments.Size == 1"></DisplayString>
<DisplayString IncludeView ="elt1">, {((TemplateArgumentLoc*)Arguments.BeginX)[1],view(cpp)}{*this,view(elt2)}</DisplayString>
<DisplayString IncludeView ="elt2" Condition="Arguments.Size == 2"></DisplayString>
<DisplayString IncludeView ="elt2">, {((TemplateArgumentLoc*)Arguments.BeginX)[2],view(cpp)}{*this,view(elt3)}</DisplayString>
<DisplayString IncludeView ="elt3" Condition="Arguments.Size == 3"></DisplayString>
<DisplayString IncludeView ="elt3">, {((TemplateArgumentLoc*)Arguments.BeginX)[3],view(cpp)}{*this,view(elt4)}</DisplayString>
<DisplayString IncludeView ="elt4" Condition="Arguments.Size == 4"></DisplayString>
<DisplayString IncludeView ="elt4">, ...</DisplayString>
<DisplayString Condition="Arguments.Size == 0">empty</DisplayString>
<DisplayString Condition="Arguments.Size != 0">&lt;{*this,view(elt0)}&gt;</DisplayString>
<DisplayString>Uninitialized</DisplayString>
</Type>
Better Visual Studio visualization of TemplateArgument and TemplateArgumentList For pack TemplateArguments, visualize all of the items in the pack Visualize a TemplateArgumentList as a template argument list. E.g., <int, double> llvm-svn: 271910
2016-06-07 01:08:32 +08:00
<Type Name="clang::TemplateArgumentList">
<DisplayString IncludeView="arg0" Condition="NumArguments==0"></DisplayString>
<DisplayString IncludeView="arg0">{Arguments[0],view(cpp)}{*this,view(arg1)}</DisplayString>
<DisplayString IncludeView="arg1" Condition="NumArguments==1"></DisplayString>
<DisplayString IncludeView="arg1">, {Arguments[1],view(cpp)}{*this,view(arg2)}</DisplayString>
<DisplayString IncludeView="arg2" Condition="NumArguments==2"></DisplayString>
Improved Visual Studio visualizations for template argument lists Improved the visualizer for TemplateArgumentList to show type arguments in the DisplayString. E.g., <double, long>. Added a visualizer for MultiLevelTemplateArgumentList. I decided to display them by how they would appear in a template with the (non-existent) template-id's omitted, so the DisplayString naturally presents as something like <double, long>::<char *>. llvm-svn: 271944
2016-06-07 05:41:20 +08:00
<DisplayString IncludeView="arg2">, {Arguments[1],view(cpp)}, ...</DisplayString>
Better Visual Studio visualization of TemplateArgument and TemplateArgumentList For pack TemplateArguments, visualize all of the items in the pack Visualize a TemplateArgumentList as a template argument list. E.g., <int, double> llvm-svn: 271910
2016-06-07 01:08:32 +08:00
<DisplayString>&lt;{*this,view(arg0)}&gt;</DisplayString>
<Expand>
<Item Name="NumArguments">NumArguments</Item>
<ArrayItems>
<Size>NumArguments</Size>
<ValuePointer>Arguments</ValuePointer>
</ArrayItems>
</Expand>
</Type>
Improved Visual Studio visualizations for template argument lists Improved the visualizer for TemplateArgumentList to show type arguments in the DisplayString. E.g., <double, long>. Added a visualizer for MultiLevelTemplateArgumentList. I decided to display them by how they would appear in a template with the (non-existent) template-id's omitted, so the DisplayString naturally presents as something like <double, long>::<char *>. llvm-svn: 271944
2016-06-07 05:41:20 +08:00
<Type Name="llvm::ArrayRef&lt;clang::TemplateArgument&gt;">
<DisplayString IncludeView="arg0" Condition="Length==0"></DisplayString>
<DisplayString IncludeView="arg0">{Data[0],view(cpp)}{*this,view(arg1)}</DisplayString>
<DisplayString IncludeView="arg1" Condition="Length==1"></DisplayString>
<DisplayString IncludeView="arg1">, {Data[1],view(cpp)}{*this,view(arg2)}</DisplayString>
<DisplayString IncludeView="arg2" Condition="Length==2"></DisplayString>
<DisplayString IncludeView="arg2">, {Data[2],view(cpp)}, ...</DisplayString>
<DisplayString>&lt;{*this,view(arg0)}&gt;</DisplayString>
Template-related improvements to Visual Studio visualizers llvm-svn: 366007
2019-07-13 23:27:53 +08:00
<Expand>
<Item Name="Length">Length</Item>
<Synthetic Name="Data">
<Expand>
<ArrayItems>
<Size>Length</Size>
<ValuePointer>Data</ValuePointer>
</ArrayItems>
</Expand>
</Synthetic>
</Expand>
Improved Visual Studio visualizations for template argument lists Improved the visualizer for TemplateArgumentList to show type arguments in the DisplayString. E.g., <double, long>. Added a visualizer for MultiLevelTemplateArgumentList. I decided to display them by how they would appear in a template with the (non-existent) template-id's omitted, so the DisplayString naturally presents as something like <double, long>::<char *>. llvm-svn: 271944
2016-06-07 05:41:20 +08:00
</Type>
<Type Name="clang::MultiLevelTemplateArgumentList">
<DisplayString IncludeView="level0" Condition="(llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.EndX - (llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.BeginX==0"></DisplayString>
<DisplayString IncludeView="level0">{((llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.BeginX)[0],view(cpp)}{*this,view(level1)}</DisplayString>
<DisplayString IncludeView="level1" Condition="(llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.EndX - (llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.BeginX==1"></DisplayString>
<DisplayString IncludeView="level1">::{((llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.BeginX)[1],view(cpp)}{*this,view(level2)}</DisplayString>
<DisplayString IncludeView="level2" Condition="(llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.EndX - (llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.BeginX==2"></DisplayString>
<DisplayString IncludeView="level2">::{((llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.BeginX)[2],view(cpp)}, ...</DisplayString>
<DisplayString>{*this,view(level0)}</DisplayString>
<Expand>
<Item Name="TemplateList">TemplateArgumentLists</Item>
</Expand>
</Type>
Visual Studio native visualizer for ParsedTemplateArgument Does a good job with type and non-type template arguments and lays the groundwork for template template arguments to visualize well once there is a TemplateName visualizer. Also fixed what looks like an incorrect comment in the header for ParsedTemplate.h. llvm-svn: 272521
2016-06-13 06:21:56 +08:00
<Type Name="clang::ParsedTemplateArgument">
Improve MSVC visualization of annot_template_id tokens Now shows the actual annotated template. E.g., {annot_template_id (A<int, double>)} Also a few miscellaneous fixes to visualizers of other types llvm-svn: 365248
2019-07-06 05:41:30 +08:00
<DisplayString Condition="Kind==clang::ParsedTemplateArgument::Type" IncludeView="cpp">{(clang::QualType *)Arg,view(cpp)na}</DisplayString>
Visual Studio native visualizer for ParsedTemplateArgument Does a good job with type and non-type template arguments and lays the groundwork for template template arguments to visualize well once there is a TemplateName visualizer. Also fixed what looks like an incorrect comment in the header for ParsedTemplate.h. llvm-svn: 272521
2016-06-13 06:21:56 +08:00
<DisplayString Condition="Kind==clang::ParsedTemplateArgument::Type">Type template argument: {*(clang::QualType *)Arg}</DisplayString>
<DisplayString Condition="Kind==clang::ParsedTemplateArgument::NonType">Non-type template argument: {*(clang::Expr *)Arg}</DisplayString>
<DisplayString Condition="Kind==clang::ParsedTemplateArgument::Template">Template template argument: {*(clang::TemplateName *)Arg</DisplayString>
<Expand>
<Item Name="Kind">Kind,en</Item>
<Item Name="Arg" Condition="Kind==clang::ParsedTemplateArgument::Type">(clang::QualType *)Arg</Item>
<Item Name="Arg" Condition="Kind==clang::ParsedTemplateArgument::NonType">(clang::Expr *)Arg</Item>
<Item Name="Arg" Condition="Kind==clang::ParsedTemplateArgument::Template">(clang::TemplateName *)Arg</Item>
</Expand>
</Type>
Better visualization of clang::BuiltinType in VisualStudio Whenever possible, use C++ names for visualizing builtin types. E.g., "long double" instead of "LongDouble" llvm-svn: 263891
2016-03-20 08:32:30 +08:00
<!-- Builtin types that have C++ keywords are manually displayed as that keyword. Otherwise, just use the enum name -->
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Type Name="clang::BuiltinType">
Better visualization of clang::BuiltinType in VisualStudio Whenever possible, use C++ names for visualizing builtin types. E.g., "long double" instead of "LongDouble" llvm-svn: 263891
2016-03-20 08:32:30 +08:00
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Void">void</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Bool">bool</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Char_U">char</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::UChar">unsigned char</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::WChar_U">wchar_t</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Char16">char16_t</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Char32">char32_t</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::UShort">unsigned short</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::UInt">unsigned int</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::ULong">unsigned long</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::ULongLong">unsigned long long</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::UInt128">__uint128_t</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Char_S">char</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::SChar">signed char</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::WChar_S">wchar_t</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Short">short</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Int">int</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Long">long</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::LongLong">long long</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Int128">__int128_t</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Half">__fp16</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Float">float</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Double">double</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::LongDouble">long double</DisplayString>
<DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::NullPtr">nullptr_t</DisplayString>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<DisplayString>{(clang::BuiltinType::Kind)BuiltinTypeBits.Kind, en}</DisplayString>
<Expand>
<Item Name="Kind">(clang::BuiltinType::Kind)BuiltinTypeBits.Kind</Item>
</Expand>
</Type>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Type Name="clang::TemplateSpecializationType">
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="arg0" Condition="TemplateSpecializationTypeBits.NumArgs==0"></DisplayString>
Visual Studio native visualizers for clang::TemplateSpecializationType Displays a template specialization as, say, A<int, double>. Does not yet handle UncommonTemplateNameStorage, QualifiedTemplateName, or DependentTemplateName, but still more than worthwhile llvm-svn: 265104
2016-04-01 11:31:43 +08:00
<DisplayString IncludeView="arg0">{((clang::TemplateArgument *)(this+1))[0],view(cpp)}{*this,view(arg1)}</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="arg1" Condition="TemplateSpecializationTypeBits.NumArgs==1"></DisplayString>
Visual Studio native visualizers for clang::TemplateSpecializationType Displays a template specialization as, say, A<int, double>. Does not yet handle UncommonTemplateNameStorage, QualifiedTemplateName, or DependentTemplateName, but still more than worthwhile llvm-svn: 265104
2016-04-01 11:31:43 +08:00
<DisplayString IncludeView="arg1">, {((clang::TemplateArgument *)(this+1))[1],view(cpp)}{*this,view(arg2)}</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="arg2" Condition="TemplateSpecializationTypeBits.NumArgs==2"></DisplayString>
Visual Studio native visualizers for clang::TemplateSpecializationType Displays a template specialization as, say, A<int, double>. Does not yet handle UncommonTemplateNameStorage, QualifiedTemplateName, or DependentTemplateName, but still more than worthwhile llvm-svn: 265104
2016-04-01 11:31:43 +08:00
<DisplayString IncludeView="arg2">, {((clang::TemplateArgument *)(this+1))[2],view(cpp)}{*this,view(arg3)}</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString Condition="(Template.Storage.Val.Value &amp; 3) == 0">
{*((clang::TemplateDecl *)(Template.Storage.Val.Value))->TemplatedDecl,view(cpp)}&lt;{*this,view(arg0)}&gt;
Visual Studio native visualizers for clang::TemplateSpecializationType Displays a template specialization as, say, A<int, double>. Does not yet handle UncommonTemplateNameStorage, QualifiedTemplateName, or DependentTemplateName, but still more than worthwhile llvm-svn: 265104
2016-04-01 11:31:43 +08:00
</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString>Can't visualize this TemplateSpecializationType</DisplayString>
Visual Studio native visualizers for clang::TemplateSpecializationType Displays a template specialization as, say, A<int, double>. Does not yet handle UncommonTemplateNameStorage, QualifiedTemplateName, or DependentTemplateName, but still more than worthwhile llvm-svn: 265104
2016-04-01 11:31:43 +08:00
<Expand>
<Item Name="Template">Template.Storage</Item>
<ArrayItems>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<Size>TemplateSpecializationTypeBits.NumArgs</Size>
Visual Studio native visualizers for clang::TemplateSpecializationType Displays a template specialization as, say, A<int, double>. Does not yet handle UncommonTemplateNameStorage, QualifiedTemplateName, or DependentTemplateName, but still more than worthwhile llvm-svn: 265104
2016-04-01 11:31:43 +08:00
<ValuePointer>(clang::TemplateArgument *)(this+1)</ValuePointer>
</ArrayItems>
Template-related improvements to Visual Studio visualizers llvm-svn: 366007
2019-07-13 23:27:53 +08:00
<ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
Visual Studio native visualizers for clang::TemplateSpecializationType Displays a template specialization as, say, A<int, double>. Does not yet handle UncommonTemplateNameStorage, QualifiedTemplateName, or DependentTemplateName, but still more than worthwhile llvm-svn: 265104
2016-04-01 11:31:43 +08:00
</Expand>
Added MSVC natvis visualizers for Type and QualType. These could probably be improved, but anything is better than staring at hex values in the debugger. llvm-svn: 248808
2015-09-30 01:32:36 +08:00
</Type>
Improve MSVC type visualizations Display TypeBits in a single line. Fix bit rot in template visualizations Rudimentary support for deduced types llvm-svn: 350470
2019-01-06 01:01:34 +08:00
<Type Name="clang::DeducedType">
<Expand>
<Item Name="isDeduced">(CanonicalType.Value.Value != this) || TypeBits.Dependent</Item>
<ExpandedItem>*(clang::Type *)this,view(cmn)</ExpandedItem>
</Expand>
</Type>
<Type Name="clang::DeducedTemplateSpecializationType">
Have MSVC Visualizer for DeducedTemplateSpecializationType show both the original template and deduced specialization Now appears in the Autos window something like - MyType DeducedTemplateSpecializationType {struct Y<int>} |- Template template<typename T> struct Y; |- Deduced As struct Y<int> |- isDeduced true bool |- TypeClass DeducedTemplateSpecialization (36) |- Flags No TypeBits set beyond TypeClass |- Canonical RecordType {struct Y<int>} Also changed QualType visualization to auto-expand the BaseType llvm-svn: 350487
2019-01-06 12:58:48 +08:00
<DisplayString Condition="(CanonicalType.Value.Value != this) || TypeBits.Dependent">{CanonicalType,view(cpp)}</DisplayString>
Improve MSVC visualizers for DeclSpec and TemplateName DeclSpec now shows the TypeRep, ExprRep, or DeclRep as appropriate TemplateName decodes and displays the StorageType A few minor refinements to other types llvm-svn: 367199
2019-07-29 11:34:40 +08:00
<DisplayString IncludeView="cpp">{Template,view(cpp)}</DisplayString>
Improve MSVC type visualizations Display TypeBits in a single line. Fix bit rot in template visualizations Rudimentary support for deduced types llvm-svn: 350470
2019-01-06 01:01:34 +08:00
<DisplayString>{Template}</DisplayString>
<Expand>
Have MSVC Visualizer for DeducedTemplateSpecializationType show both the original template and deduced specialization Now appears in the Autos window something like - MyType DeducedTemplateSpecializationType {struct Y<int>} |- Template template<typename T> struct Y; |- Deduced As struct Y<int> |- isDeduced true bool |- TypeClass DeducedTemplateSpecialization (36) |- Flags No TypeBits set beyond TypeClass |- Canonical RecordType {struct Y<int>} Also changed QualType visualization to auto-expand the BaseType llvm-svn: 350487
2019-01-06 12:58:48 +08:00
<Item Name="Template">Template</Item>
<Item Name="Deduced As" Condition="(CanonicalType.Value.Value != this) || TypeBits.Dependent">CanonicalType,view(cpp)</Item>
Improve MSVC visualizers for DeclSpec and TemplateName DeclSpec now shows the TypeRep, ExprRep, or DeclRep as appropriate TemplateName decodes and displays the StorageType A few minor refinements to other types llvm-svn: 367199
2019-07-29 11:34:40 +08:00
<ExpandedItem>(clang::DeducedType *)this</ExpandedItem>
Have MSVC Visualizer for DeducedTemplateSpecializationType show both the original template and deduced specialization Now appears in the Autos window something like - MyType DeducedTemplateSpecializationType {struct Y<int>} |- Template template<typename T> struct Y; |- Deduced As struct Y<int> |- isDeduced true bool |- TypeClass DeducedTemplateSpecialization (36) |- Flags No TypeBits set beyond TypeClass |- Canonical RecordType {struct Y<int>} Also changed QualType visualization to auto-expand the BaseType llvm-svn: 350487
2019-01-06 12:58:48 +08:00
<Item Name="Template">Template</Item>
</Expand>
</Type>
<Type Name="clang::ClassTemplateSpecializationDecl">
<DisplayString>{*(CXXRecordDecl *)this,nd}{*TemplateArgs}</DisplayString>
<Expand>
<ExpandedItem>(CXXRecordDecl *)this,nd</ExpandedItem>
<Item Name="TemplateArgs">TemplateArgs</Item>
Improve MSVC type visualizations Display TypeBits in a single line. Fix bit rot in template visualizations Rudimentary support for deduced types llvm-svn: 350470
2019-01-06 01:01:34 +08:00
</Expand>
</Type>
Since Visual Studio 2012 is the minimum version of MSVC we support, the old-style visualizers are being removed. Adding a Natvis replacement for the debugging visualizers. llvm-svn: 200032
2014-01-25 03:46:45 +08:00
<Type Name="clang::IdentifierInfo">
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<DisplayString Condition="Entry != 0">{((llvm::StringMapEntry&lt;clang::IdentifierInfo *&gt;*)Entry)+1,sb}</DisplayString>
Since Visual Studio 2012 is the minimum version of MSVC we support, the old-style visualizers are being removed. Adding a Natvis replacement for the debugging visualizers. llvm-svn: 200032
2014-01-25 03:46:45 +08:00
<Expand>
<Item Condition="Entry != 0" Name="[Identifier]">((llvm::StringMapEntry&lt;clang::IdentifierInfo *&gt;*)Entry)+1,s</Item>
<Item Name="Token Kind">(clang::tok::TokenKind)TokenID</Item>
</Expand>
</Type>
<Type Name="clang::DeclarationName">
Visual Studio Visualizers for clang::FunctionDecl Readably displays a FunctionDecl in the Visual Studio Locals Window something like: void g(int, double d, struct A && arr) llvm-svn: 263915
2016-03-21 04:15:23 +08:00
<DisplayString Condition="Ptr == 0" IncludeView="cpp"></DisplayString>
Since Visual Studio 2012 is the minimum version of MSVC we support, the old-style visualizers are being removed. Adding a Natvis replacement for the debugging visualizers. llvm-svn: 200032
2014-01-25 03:46:45 +08:00
<DisplayString Condition="Ptr == 0">Empty</DisplayString>
Add visualizers for more clang types. Create more C++-like visualizations for existing Clang types Created visualizer for PointerType, LValueReferenceType, RValueReferenceType, and TemplateParmType. In addition, cleaned up the display of existing types to be more C++-like. For example, instead of SubstTemplateTypeParmType: {Identifier (("T"))} => Record (25), {Identifier (("A"))} it now displays more readably as SubstTemplateTypeParmType: {typename T <= struct A} The <expand> sections still can be used for all the gory details if necessary. llvm-svn: 263638
2016-03-16 22:27:50 +08:00
<DisplayString Condition="(Ptr &amp; PtrMask) == StoredIdentifier" IncludeView="cpp">{*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)}</DisplayString>
Add a Visualizer for VarDecl. Reviewed by: Aaron Ballman Differential Revision: http://reviews.llvm.org/D4303 llvm-svn: 211788
2014-06-27 00:26:42 +08:00
<DisplayString Condition="(Ptr &amp; PtrMask) == StoredIdentifier">{{Identifier ({*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)})}}</DisplayString>
<DisplayString Condition="(Ptr &amp; PtrMask) == StoredObjCZeroArgSelector">{{ObjC Zero Arg Selector (*{(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)})}}</DisplayString>
<DisplayString Condition="(Ptr &amp; PtrMask) == StoredObjCOneArgSelector">{{ObjC One Arg Selector (*{(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)})}}</DisplayString>
Natural MSVC visualization of constructors E.g., Allow MSVC to visualize a CXXConstructorDecl like Constructor { Y(type_identity_t<T>)} llvm-svn: 364138
2019-06-23 02:56:40 +08:00
<DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXConstructorName" IncludeView="cpp">{(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),view(cpp)na}</DisplayString>
<DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXConstructorName">C++ Constructor {{{(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),view(cpp)na}}}</DisplayString>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXDestructorName">C++ Destructor {{*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask)}}</DisplayString>
<DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXConversionFunctionName">C++ Conversion function {{*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask)}}</DisplayString>
<DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXOperatorName">C++ Operator {{*(clang::detail::CXXOperatorIdName *)(Ptr &amp; ~PtrMask)}}</DisplayString>
Visual Studio Native Visualizations for constructors and methods With this change, the class struct A { A(int _i); ~A(); int foo(double d); double bar(A *a) { return 1.3; } }; appears in the VS2015 Locals Window as D 0x02dbb378 struct A |- DeclKind CXXRecord |- Members |- [0] implicit struct A |- [1] Constructor {A(int _i)} |- [2] Destructor {~A()} |- [3] Method {int foo(double d)} |- [4] Method {double bar(struct A *)} |- [Raw View] /* Other stuff */ Note that these changes only benefit VS2015 as VS2013 does not have views and only displays the struct name "A", but the change does no apparent harm in VS2013, so is still a win. llvm-svn: 264020
2016-03-22 10:29:22 +08:00
<DisplayString Condition="(Ptr &amp; PtrMask) == StoredDeclarationNameExtra"
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
IncludeView="cpp">{*(clang::detail::DeclarationNameExtra *)(Ptr &amp; ~PtrMask),view(cpp)}</DisplayString>
<DisplayString Condition="(Ptr &amp; PtrMask) == StoredDeclarationNameExtra">{{Extra ({*(clang::detail::DeclarationNameExtra *)(Ptr &amp; ~PtrMask)})}}</DisplayString>
Since Visual Studio 2012 is the minimum version of MSVC we support, the old-style visualizers are being removed. Adding a Natvis replacement for the debugging visualizers. llvm-svn: 200032
2014-01-25 03:46:45 +08:00
<Expand>
Various tweaks to MSVC natvis visualizers Make more consistent use of na format. Improve visualization of deduction guides. Add visualizer for explicit specifier (including conditionally explicit) Fix some typos llvm-svn: 364724
2019-07-01 06:04:25 +08:00
<Item Name="Kind">StoredNameKind(Ptr &amp; PtrMask),en</Item>
<Item Condition="(Ptr &amp; PtrMask) == StoredIdentifier" Name="[Identifier]">*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask),na</Item>
<Item Condition="(Ptr &amp; PtrMask) == StoredObjCZeroArgSelector" Name="[ObjC Zero Arg Selector]">*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask),na</Item>
<Item Condition="(Ptr &amp; PtrMask) == StoredObjCOneArgSelector" Name="[ObjC One Arg Selector]">*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask),na</Item>
<Item Condition="(Ptr &amp; PtrMask) == StoredCXXConstructorName" Name="[C++ Constructor]">*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),na</Item>
<Item Condition="(Ptr &amp; PtrMask) == StoredCXXDestructorName" Name="[C++ Destructor]">*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),na</Item>
<Item Condition="(Ptr &amp; PtrMask) == StoredCXXConversionFunctionName" Name="[C++ Conversion function]">*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),na</Item>
<Item Condition="(Ptr &amp; PtrMask) == StoredCXXOperatorName" Name="[C++ Operator]">*(clang::detail::CXXOperatorIdName *)(Ptr &amp; ~PtrMask),na</Item>
<Item Condition="(Ptr &amp; PtrMask) == StoredDeclarationNameExtra" Name="[Extra]">(clang::detail::DeclarationNameExtra *)(Ptr &amp; ~PtrMask),na</Item>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
</Expand>
</Type>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<Type Name="clang::detail::DeclarationNameExtra">
Various tweaks to MSVC natvis visualizers Make more consistent use of na format. Improve visualization of deduction guides. Add visualizer for explicit specifier (including conditionally explicit) Fix some typos llvm-svn: 364724
2019-07-01 06:04:25 +08:00
<DisplayString Condition="ExtraKindOrNumArgs == CXXDeductionGuideName" IncludeView="cpp">
{(CXXDeductionGuideNameExtra *)this,view(cpp)nand}
</DisplayString>
<DisplayString Condition="ExtraKindOrNumArgs == CXXDeductionGuideName">
{(CXXDeductionGuideNameExtra *)this,nand}
</DisplayString>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<DisplayString Condition="ExtraKindOrNumArgs == CXXLiteralOperatorName">C++ Literal operator</DisplayString>
<DisplayString Condition="ExtraKindOrNumArgs == CXXUsingDirective">C++ Using directive</DisplayString>
<DisplayString>{(clang::detail::DeclarationNameExtra::ExtraKind)ExtraKindOrNumArgs,en}{" ",sb}{*this,view(cpp)}</DisplayString>
Various tweaks to MSVC natvis visualizers Make more consistent use of na format. Improve visualization of deduction guides. Add visualizer for explicit specifier (including conditionally explicit) Fix some typos llvm-svn: 364724
2019-07-01 06:04:25 +08:00
<Expand>
<ExpandedItem Condition="ExtraKindOrNumArgs == CXXDeductionGuideName">(CXXDeductionGuideNameExtra *)this</ExpandedItem>
<Item Name="ExtraKindOrNumArgs" Condition="ExtraKindOrNumArgs != CXXDeductionGuideName">ExtraKindOrNumArgs</Item>
</Expand>
</Type>
<Type Name="clang::detail::CXXDeductionGuideNameExtra">
<DisplayString IncludeView="cpp">{Template->TemplatedDecl,view(cpp)}</DisplayString>
Improve MSVC visualization of annot_template_id tokens Now shows the actual annotated template. E.g., {annot_template_id (A<int, double>)} Also a few miscellaneous fixes to visualizers of other types llvm-svn: 365248
2019-07-06 05:41:30 +08:00
<DisplayString>C++ Deduction guide for {Template->TemplatedDecl,view(cpp)na}</DisplayString>
Visual Studio Native Visualizations for constructors and methods With this change, the class struct A { A(int _i); ~A(); int foo(double d); double bar(A *a) { return 1.3; } }; appears in the VS2015 Locals Window as D 0x02dbb378 struct A |- DeclKind CXXRecord |- Members |- [0] implicit struct A |- [1] Constructor {A(int _i)} |- [2] Destructor {~A()} |- [3] Method {int foo(double d)} |- [4] Method {double bar(struct A *)} |- [Raw View] /* Other stuff */ Note that these changes only benefit VS2015 as VS2013 does not have views and only displays the struct name "A", but the change does no apparent harm in VS2013, so is still a win. llvm-svn: 264020
2016-03-22 10:29:22 +08:00
</Type>
Natural MSVC visualization of constructors E.g., Allow MSVC to visualize a CXXConstructorDecl like Constructor { Y(type_identity_t<T>)} llvm-svn: 364138
2019-06-23 02:56:40 +08:00
<Type Name="clang::detail::CXXSpecialNameExtra">
<DisplayString IncludeView="cpp">{Type,view(cpp)}</DisplayString>
<DisplayString>{Type}</DisplayString>
</Type>
Various tweaks to MSVC natvis visualizers Make more consistent use of na format. Improve visualization of deduction guides. Add visualizer for explicit specifier (including conditionally explicit) Fix some typos llvm-svn: 364724
2019-07-01 06:04:25 +08:00
<Type Name="clang::DeclarationNameInfo">
<DisplayString>{Name}</DisplayString>
</Type>
Improve MSVC visualization of annot_template_id tokens Now shows the actual annotated template. E.g., {annot_template_id (A<int, double>)} Also a few miscellaneous fixes to visualizers of other types llvm-svn: 365248
2019-07-06 05:41:30 +08:00
<Type Name="clang::TemplateIdAnnotation">
<DisplayString IncludeView="arg0" Condition="NumArgs==0"></DisplayString>
<DisplayString IncludeView="arg0">{(ParsedTemplateArgument *)(this+1),view(cpp)na}{this,view(arg1)na}</DisplayString>
<DisplayString IncludeView="arg1" Condition="NumArgs==1"></DisplayString>
<DisplayString IncludeView="arg1">, {((ParsedTemplateArgument *)(this+1))+1,view(cpp)na}{this,view(arg2)na}</DisplayString>
<DisplayString IncludeView="arg2" Condition="NumArgs==2"></DisplayString>
<DisplayString IncludeView="arg1">, ...</DisplayString>
<DisplayString>{Name,na}&lt;{this,view(arg0)na}&gt;</DisplayString>
<Expand>
<Item Name="Name">Name</Item>
<Synthetic Name="Arguments">
<DisplayString>{this,view(arg0)na}</DisplayString>
<Expand>
<ArrayItems>
<Size>NumArgs</Size>
<ValuePointer>(ParsedTemplateArgument *)(this+1)</ValuePointer>
</ArrayItems>
</Expand>
</Synthetic>
<Item Name="Operator">Operator</Item>
</Expand>
</Type>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Type Name="clang::Token">
Improve MSVC visualization of annot_template_id tokens Now shows the actual annotated template. E.g., {annot_template_id (A<int, double>)} Also a few miscellaneous fixes to visualizers of other types llvm-svn: 365248
2019-07-06 05:41:30 +08:00
<DisplayString Condition="Kind == clang::tok::annot_template_id">{{annot_template_id ({(clang::TemplateIdAnnotation *)(PtrData),na})}}</DisplayString>
<DisplayString Condition="Kind == clang::tok::identifier">{{Identifier ({(clang::IdentifierInfo *)(PtrData),na})}}</DisplayString>
<DisplayString>{(clang::tok::TokenKind)Kind,en}</DisplayString>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
</Type>
Improve MSVC visualizations so the parser shows where we are in the code Also provide a visualizer for lambda introducers llvm-svn: 368029
2019-08-06 21:29:35 +08:00
<Type Name="clang::Lexer">
<DisplayString>{BufferPtr,nasb}</DisplayString>
</Type>
<Type Name="clang::Preprocessor::IncludeStackInfo">
<DisplayString Condition="TheLexer._Mypair._Myval2 != 0">{TheLexer._Mypair._Myval2,na}</DisplayString>
<DisplayString Condition="TheTokenLexer._Mypair._Myval2 != 0">Expanding Macro: {TheTokenLexer._Mypair._Myval2,na}</DisplayString>
<DisplayString></DisplayString>
</Type>
<Type Name="clang::Preprocessor">
<DisplayString IncludeView="cached" Condition="CachedLexPos &lt; CachedTokens.Size">
[{(Token *)(CachedTokens.BeginX) + CachedLexPos,na}] {IncludeMacroStack._Mypair._Myval2._Mylast - 1,na}
</DisplayString>
<DisplayString IncludeView="cached"> {IncludeMacroStack._Mypair._Myval2._Mylast - 1,na}</DisplayString>
<DisplayString Condition="CurLexer._Mypair._Myval2 != 0">{CurLexer._Mypair._Myval2,na}</DisplayString>
<DisplayString Condition="CurTokenLexer._Mypair._Myval2 != 0">Expanding Macro: {CurTokenLexer._Mypair._Myval2,na}</DisplayString>
<!-- Can't use CurLexerKind because natvis sees the type rather than the variable -->
<DisplayString Condition="IncludeMacroStack._Mypair._Myval2._Mylast - IncludeMacroStack._Mypair._Myval2._Myfirst">
{this,view(cached)}
</DisplayString>
<DisplayString>CLK_LexAfterModuleImport</DisplayString>
</Type>
<Type Name="clang::Parser">
<DisplayString>[{Tok}] {PP,na}</DisplayString>
</Type>
<Type Name="clang::LambdaIntroducer::LambdaCapture">
<DisplayString Condition="Kind == LCK_This">this</DisplayString>
<DisplayString Condition="Kind == LCK_StarThis">*this</DisplayString>
<DisplayString Condition="Kind == LCK_ByCopy">{Id}</DisplayString>
<DisplayString Condition="Kind == LCK_ByRef">&amp;{Id}</DisplayString>
<DisplayString>No visualizer for {Kind}</DisplayString>
</Type>
<Type Name="clang::LambdaIntroducer">
<DisplayString IncludeView="default" Condition="Default==LCD_None"></DisplayString>
<DisplayString IncludeView="default" Condition="Default==LCD_ByCopy">=,</DisplayString>
<DisplayString IncludeView="default" Condition="Default==LCD_ByRef">&amp;,</DisplayString>
<DisplayString IncludeView="capture0" Condition="Captures.Size==0"></DisplayString>
<DisplayString IncludeView="capture0">{(LambdaCapture *)(Captures.BeginX),na}{this,view(capture1)na}</DisplayString>
<DisplayString IncludeView="capture1" Condition="Captures.Size==1"></DisplayString>
<DisplayString IncludeView="capture1">,{(LambdaCapture *)(Captures.BeginX)+1,na}{this,view(capture2)na}</DisplayString>
<DisplayString IncludeView="capture2" Condition="Captures.Size==2"></DisplayString>
<DisplayString IncludeView="capture2">,{(LambdaCapture *)(Captures.BeginX)+2,na}{this,view(capture3)na}</DisplayString>
<DisplayString IncludeView="capture3" Condition="Captures.Size==3"></DisplayString>
<DisplayString IncludeView="capture3">,...</DisplayString>
<DisplayString>[{this,view(default)na}{this,view(capture0)na}]</DisplayString>
</Type>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Type Name="clang::DeclSpec">
Improve MSVC visualizers for DeclSpec and TemplateName DeclSpec now shows the TypeRep, ExprRep, or DeclRep as appropriate TemplateName decodes and displays the StorageType A few minor refinements to other types llvm-svn: 367199
2019-07-29 11:34:40 +08:00
<DisplayString IncludeView="extra" Condition="TypeSpecType == TST_typename || TypeSpecType == TST_typeofType || TypeSpecType == TST_underlyingType || TypeSpecType == TST_atomic">
, [{TypeRep}]
</DisplayString>
<DisplayString IncludeView="extra" Condition="TypeSpecType == TST_typeofExpr || TypeSpecType == TST_decltype">
, [{ExprRep}]
</DisplayString>
<DisplayString IncludeView="extra" Condition="TypeSpecType == TST_enum || TypeSpecType == TST_struct || TypeSpecType == TST_interface || TypeSpecType == TST_union || TypeSpecType == TST_class">
, [{DeclRep}]
</DisplayString>
<DisplayString IncludeView="extra"></DisplayString>
<DisplayString>[{(clang::DeclSpec::SCS)StorageClassSpec,en}], [{(clang::TypeSpecifierType)TypeSpecType,en}]{this,view(extra)na}</DisplayString>
<Expand>
<Item Name="StorageClassSpec">(clang::DeclSpec::SCS)StorageClassSpec</Item>
<Item Name="TypeSpecType">(clang::TypeSpecifierType)TypeSpecType</Item>
<Item Name="TypeRep" Condition="TypeSpecType == TST_typename || TypeSpecType == TST_typeofType || TypeSpecType == TST_underlyingType || TypeSpecType == TST_atomic">
TypeRep
</Item>
<Item Name="ExprRep" Condition="TypeSpecType == TST_typeofExpr || TypeSpecType == TST_decltype">
ExprRep
</Item>
<Item Name="DeclRep" Condition="TypeSpecType == TST_enum || TypeSpecType == TST_struct || TypeSpecType == TST_interface || TypeSpecType == TST_union || TypeSpecType == TST_class">
DeclRep
</Item>
</Expand>
Since Visual Studio 2012 is the minimum version of MSVC we support, the old-style visualizers are being removed. Adding a Natvis replacement for the debugging visualizers. llvm-svn: 200032
2014-01-25 03:46:45 +08:00
</Type>
<Type Name="clang::PragmaHandler">
<DisplayString>{Name,s}</DisplayString>
</Type>
<Type Name="clang::FileEntry">
<DisplayString>{Name,s}</DisplayString>
</Type>
<Type Name="clang::DirectoryEntry">
<DisplayString>{Name,s}</DisplayString>
</Type>
Add a Visualizer for VarDecl. Reviewed by: Aaron Ballman Differential Revision: http://reviews.llvm.org/D4303 llvm-svn: 211788
2014-06-27 00:26:42 +08:00
<Type Name="clang::VarDecl::VarDeclBitfields">
<Expand>
<Item Name="StorageClass">(clang::StorageClass)SClass</Item>
<Item Name="ThreadStorageClass">(clang::ThreadStorageClassSpecifier)TSCSpec</Item>
<Item Name="InitStyle">(clang::VarDecl::InitializationStyle)InitStyle</Item>
</Expand>
</Type>
Visual Studio Visualizers for clang::FunctionDecl Readably displays a FunctionDecl in the Visual Studio Locals Window something like: void g(int, double d, struct A && arr) llvm-svn: 263915
2016-03-21 04:15:23 +08:00
<Type Name="clang::DeclaratorDecl">
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString>{DeclType,view(left)} {Name,view(cpp)}{DeclType,view(right)}</DisplayString>
Improve Visual Studio visualization of DeclaratorDecl With this change, you can now expand its name and type. llvm-svn: 271966
2016-06-07 08:27:37 +08:00
<Expand>
<Item Name="Name">Name</Item>
<Item Name="DeclType">DeclType</Item>
</Expand>
Visual Studio Visualizers for clang::FunctionDecl Readably displays a FunctionDecl in the Visual Studio Locals Window something like: void g(int, double d, struct A && arr) llvm-svn: 263915
2016-03-21 04:15:23 +08:00
</Type>
Add a Visualizer for VarDecl. Reviewed by: Aaron Ballman Differential Revision: http://reviews.llvm.org/D4303 llvm-svn: 211788
2014-06-27 00:26:42 +08:00
<Type Name="clang::VarDecl">
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString>{(DeclaratorDecl*)this,nand}</DisplayString>
Add a Visualizer for VarDecl. Reviewed by: Aaron Ballman Differential Revision: http://reviews.llvm.org/D4303 llvm-svn: 211788
2014-06-27 00:26:42 +08:00
<Expand>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<ExpandedItem>(DeclaratorDecl*)this,nd</ExpandedItem>
Improve MSVC visualizations so the parser shows where we are in the code Also provide a visualizer for lambda introducers llvm-svn: 368029
2019-08-06 21:29:35 +08:00
<Item Name="Init">Init</Item>
Add a Visualizer for VarDecl. Reviewed by: Aaron Ballman Differential Revision: http://reviews.llvm.org/D4303 llvm-svn: 211788
2014-06-27 00:26:42 +08:00
<Item Name="VarDeclBits">VarDeclBits</Item>
Visual Studio Visualizers for clang::FunctionDecl Readably displays a FunctionDecl in the Visual Studio Locals Window something like: void g(int, double d, struct A && arr) llvm-svn: 263915
2016-03-21 04:15:23 +08:00
</Expand>
</Type>
<Type Name="clang::ParmVarDecl">
<DisplayString>{*(VarDecl*)this,nd}</DisplayString>
<Expand>
Add a Visualizer for VarDecl. Reviewed by: Aaron Ballman Differential Revision: http://reviews.llvm.org/D4303 llvm-svn: 211788
2014-06-27 00:26:42 +08:00
<Item Name="ParmVarDeclBits">ParmVarDeclBits</Item>
Visual Studio Visualizers for clang::FunctionDecl Readably displays a FunctionDecl in the Visual Studio Locals Window something like: void g(int, double d, struct A && arr) llvm-svn: 263915
2016-03-21 04:15:23 +08:00
<ExpandedItem>*(VarDecl*)this,nd</ExpandedItem>
</Expand>
</Type>
Various tweaks to MSVC natvis visualizers Make more consistent use of na format. Improve visualization of deduction guides. Add visualizer for explicit specifier (including conditionally explicit) Fix some typos llvm-svn: 364724
2019-07-01 06:04:25 +08:00
<Type Name="clang::ExplicitSpecifier">
<DisplayString Condition="((ExplicitSpec.Value&gt;1) &amp; 3) == ExplicitSpecKind::ResolvedTrue" IncludeView="cpp">{"explicit ",sb}</DisplayString>
<DisplayString Condition="((ExplicitSpec.Value&gt;1) &amp; 3) == ExplicitSpecKind::ResolvedFalse" IncludeView="cpp"></DisplayString>
<DisplayString Condition="((ExplicitSpec.Value&gt;1) &amp; 3) == ExplicitSpecKind::Unresolved" IncludeView="cpp">explicit({ExplicitSpec,view(ptr)na})</DisplayString>
<DisplayString Condition="(ExplicitSpec.Value&amp;~7) == 0">{ExplicitSpec,view(int)en}</DisplayString>
<DisplayString>{ExplicitSpec,view(int)en} : {ExplicitSpec,view(ptr)na}</DisplayString>
</Type>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<Type Name="clang::CXXDeductionGuideDecl">
Various tweaks to MSVC natvis visualizers Make more consistent use of na format. Improve visualization of deduction guides. Add visualizer for explicit specifier (including conditionally explicit) Fix some typos llvm-svn: 364724
2019-07-01 06:04:25 +08:00
<DisplayString>{ExplicitSpec,view(cpp)}{Name,view(cpp)nd}({(FunctionDecl*)this,view(parm0)nand}) -&gt; {((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)->ResultType,view(cpp)}</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<Expand>
Various tweaks to MSVC natvis visualizers Make more consistent use of na format. Improve visualization of deduction guides. Add visualizer for explicit specifier (including conditionally explicit) Fix some typos llvm-svn: 364724
2019-07-01 06:04:25 +08:00
<Item Name="ExplicitSpec">ExplicitSpec</Item>
<Item Name="IsCopyDeductionCandidate">(bool)FunctionDeclBits.IsCopyDeductionCandidate</Item>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<ExpandedItem>(FunctionDecl*)this,nd</ExpandedItem>
</Expand>
</Type>
Visual Studio Visualizers for clang::FunctionDecl Readably displays a FunctionDecl in the Visual Studio Locals Window something like: void g(int, double d, struct A && arr) llvm-svn: 263915
2016-03-21 04:15:23 +08:00
<Type Name="clang::FunctionDecl">
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="retType">{((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)->ResultType,view(cpp)}</DisplayString>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<DisplayString IncludeView="parm0" Condition="0 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams"></DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="parm0">{ParamInfo[0],na}{*this,view(parm1)nd}</DisplayString>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<DisplayString IncludeView="parm1" Condition="1 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams"></DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="parm1">, {ParamInfo[1],na}{*this,view(parm2)nd}</DisplayString>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<DisplayString IncludeView="parm2" Condition="2 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams"></DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="parm2">, {ParamInfo[2],na}{*this,view(parm3)nd}</DisplayString>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<DisplayString IncludeView="parm3" Condition="3 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams"></DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="parm3">, {ParamInfo[3],na}{*this,view(parm4)nd}</DisplayString>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<DisplayString IncludeView="parm4" Condition="4 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams"></DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString IncludeView="parm4">, {ParamInfo[4],na}{*this,view(parm5)nd}</DisplayString>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<DisplayString IncludeView="parm5" Condition="5 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams"></DisplayString>
Visual Studio Visualizers for clang::FunctionDecl Readably displays a FunctionDecl in the Visual Studio Locals Window something like: void g(int, double d, struct A && arr) llvm-svn: 263915
2016-03-21 04:15:23 +08:00
<DisplayString IncludeView="parm5">, /* expand for more params */</DisplayString>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString Condition="((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.HasTrailingReturn">
auto {Name,view(cpp)nd}({*this,view(parm0)nd}) -&gt; {((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)->ResultType,view(cpp)}
</DisplayString>
<DisplayString>{this,view(retType)nand} {Name,view(cpp)nd}({*this,view(parm0)nd})</DisplayString>
Visual Studio Visualizers for clang::FunctionDecl Readably displays a FunctionDecl in the Visual Studio Locals Window something like: void g(int, double d, struct A && arr) llvm-svn: 263915
2016-03-21 04:15:23 +08:00
<Expand>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<ExpandedItem>(clang::DeclaratorDecl *)this,nd</ExpandedItem>
Template-related improvements to Visual Studio visualizers llvm-svn: 366007
2019-07-13 23:27:53 +08:00
<Item Name="ReturnType">((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)->ResultType</Item>
Visual Studio Visualizers for clang::FunctionDecl Readably displays a FunctionDecl in the Visual Studio Locals Window something like: void g(int, double d, struct A && arr) llvm-svn: 263915
2016-03-21 04:15:23 +08:00
<Synthetic Name="Parameter Types">
Visual Studio Native Visualizations for constructors and methods With this change, the class struct A { A(int _i); ~A(); int foo(double d); double bar(A *a) { return 1.3; } }; appears in the VS2015 Locals Window as D 0x02dbb378 struct A |- DeclKind CXXRecord |- Members |- [0] implicit struct A |- [1] Constructor {A(int _i)} |- [2] Destructor {~A()} |- [3] Method {int foo(double d)} |- [4] Method {double bar(struct A *)} |- [Raw View] /* Other stuff */ Note that these changes only benefit VS2015 as VS2013 does not have views and only displays the struct name "A", but the change does no apparent harm in VS2013, so is still a win. llvm-svn: 264020
2016-03-22 10:29:22 +08:00
<DisplayString>{*this,view(parm0)nd}</DisplayString>
Visual Studio Visualizers for clang::FunctionDecl Readably displays a FunctionDecl in the Visual Studio Locals Window something like: void g(int, double d, struct A && arr) llvm-svn: 263915
2016-03-21 04:15:23 +08:00
<Expand>
<ArrayItems>
Fix errors with the Clang natvis file. This updates the FunctionProtoType visualizer to use the proper bits for determining parameter information and the DeclarationName visualizer to use the detail namespace. It also adds support for viewing newer special declaration names (like deduction guides). Patch with help of Bruno Ricci. llvm-svn: 349547
2018-12-19 05:42:20 +08:00
<Size>((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams</Size>
Visual Studio Visualizers for clang::FunctionDecl Readably displays a FunctionDecl in the Visual Studio Locals Window something like: void g(int, double d, struct A && arr) llvm-svn: 263915
2016-03-21 04:15:23 +08:00
<ValuePointer>ParamInfo</ValuePointer>
</ArrayItems>
</Expand>
</Synthetic>
Template-related improvements to Visual Studio visualizers llvm-svn: 366007
2019-07-13 23:27:53 +08:00
<Item Name="TemplateOrSpecialization">TemplateOrSpecialization</Item>
Add a Visualizer for VarDecl. Reviewed by: Aaron Ballman Differential Revision: http://reviews.llvm.org/D4303 llvm-svn: 211788
2014-06-27 00:26:42 +08:00
</Expand>
</Type>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Type Name="clang::OpaquePtr&lt;*&gt;">
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<DisplayString>{*($T1*)&amp;Ptr}</DisplayString>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
<Expand>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<ExpandedItem>($T1*)&amp;Ptr</ExpandedItem>
Add Visual Studio native visualizers for several Clang types This is one of a series of changes to improve the MSVC visualization of Clang types. This one focuses on Record and SubstTemplateTypeParmType meaning that, for example, a TemplateArgumentLoc no longer displays incomprehensibly in the locals window as {Argument={DeclArg={Kind=1 QT=0x033acb00 D=0xcccccccc {DeclType=???}}... but instead much more usefully as Type template parameter: SubstTemplateTypeParm: {Identifier (("T"))} => Record, {Identifier (("A"))} Additional types and improvements will be made in subsequent commits llvm-svn: 262933
2016-03-09 00:14:23 +08:00
</Expand>
</Type>
Improved Visual Studio visualization of OpaquePtr Create a special visualizer for OpaquePtr<QualType> because the standard visualizer doesn't work with OpaquePtr<QualType> due to QualType being heavily dependent on traits to be pointer-like. Also, created an identical visualizer for UnionOpaquePtr llvm-svn: 272531
2016-06-13 12:02:35 +08:00
<Type Name="clang::UnionOpaquePtr&lt;*&gt;">
<DisplayString>{($T1 *)Ptr}</DisplayString>
<Expand>
<ExpandedItem>($T1 *)Ptr</ExpandedItem>
</Expand>
</Type>
Visual Studio native visualization for TemplateParameterList and TemplateTypeParmDecl With this change, a TemplateParameterList will suggestively display in the locals window something like: <typename T, int i> llvm-svn: 264714
2016-03-29 18:57:24 +08:00
<Type Name="clang::TemplateParameterList">
<DisplayString IncludeView="parm0" Condition="NumParams==0"></DisplayString>
<DisplayString IncludeView="parm0">{*((NamedDecl **)(this+1))[0],view(cpp)}{*this,view(parm1)}</DisplayString>
<DisplayString IncludeView="parm1" Condition="NumParams==1"></DisplayString>
<DisplayString IncludeView="parm1">, {*((NamedDecl **)(this+1))[1],view(cpp)}{*this,view(parm2)}</DisplayString>
<DisplayString IncludeView="parm2" Condition="NumParams==2"></DisplayString>
<DisplayString IncludeView="parm2">, {*((NamedDecl **)(this+1))[2],view(cpp)}{*this,view(parm3)}</DisplayString>
<DisplayString IncludeView="parm3" Condition="NumParams==3"></DisplayString>
<DisplayString IncludeView="parm3">, {*((NamedDecl **)(this+1))[3],view(cpp)}{*this,view(parm4)}</DisplayString>
<DisplayString IncludeView="parm4" Condition="NumParams==4"></DisplayString>
<DisplayString IncludeView="parm4">, {*((NamedDecl **)(this+1))[4],view(cpp)}{*this,view(parm5)}</DisplayString>
<DisplayString IncludeView="parm5" Condition="NumParams==5"></DisplayString>
<DisplayString IncludeView="parm5">, /* Expand for more params */</DisplayString>
<DisplayString>&lt;{*this,view(parm0)}&gt;</DisplayString>
<Expand>
<ArrayItems>
<Size>NumParams</Size>
<ValuePointer>(NamedDecl **)(this+1)</ValuePointer>
</ArrayItems>
</Expand>
</Type>
Rudimentary support for Visual Studio Stmt visualizer Better than nothing... llvm-svn: 272518
2016-06-13 02:42:04 +08:00
<Type Name="clang::Stmt">
<DisplayString>{(clang::Stmt::StmtClass)StmtBits.sClass,en}</DisplayString>
<Expand>
<Item Name="Class">(clang::Stmt::StmtClass)StmtBits.sClass,en</Item>
</Expand>
</Type>
Simple visualization of expressions While more could be done, showing the type is a lot better than what is there now. llvm-svn: 269623
2016-05-16 09:36:09 +08:00
<Type Name="clang::Expr">
Slightly improve Visual Studio visualization of clang::Expr Now it gives the StmtClass of the Expr as well as the type. It's still a long way from full visualization of expressions, but I have found that having the class really helps when debugging, so definitely worth submitting. llvm-svn: 271866
2016-06-06 11:37:18 +08:00
<DisplayString>Expression of class {(clang::Stmt::StmtClass)StmtBits.sClass,en} and type {TR,view(cpp)}</DisplayString>
Simple visualization of expressions While more could be done, showing the type is a lot better than what is there now. llvm-svn: 269623
2016-05-16 09:36:09 +08:00
</Type>
Visual Studio visualizers associated with LookupResults Visualizers for DeclAccessPair, UnresolvedSet, and LookupResult. For example, when combined with LLVM diff D21256 (currently in review), a Lookup set will show much more naturally in the Locals window something like Found: {public typename ...Ts} llvm-svn: 272448
2016-06-11 11:02:33 +08:00
<Type Name="clang::DeclAccessPair">
<DisplayString IncludeView="access" Condition="(Ptr&amp;Mask) == clang::AS_public">public</DisplayString>
<DisplayString IncludeView="access" Condition="(Ptr&amp;Mask) == clang::AS_protected">protected</DisplayString>
<DisplayString IncludeView="access" Condition="(Ptr&amp;Mask) == clang::AS_private">private</DisplayString>
Various tweaks to MSVC natvis visualizers Make more consistent use of na format. Improve visualization of deduction guides. Add visualizer for explicit specifier (including conditionally explicit) Fix some typos llvm-svn: 364724
2019-07-01 06:04:25 +08:00
<DisplayString IncludeView="access" Condition="(Ptr&amp;Mask) == clang::AS_none"></DisplayString>
Visual Studio visualizers associated with LookupResults Visualizers for DeclAccessPair, UnresolvedSet, and LookupResult. For example, when combined with LLVM diff D21256 (currently in review), a Lookup set will show much more naturally in the Locals window something like Found: {public typename ...Ts} llvm-svn: 272448
2016-06-11 11:02:33 +08:00
<DisplayString IncludeView="decl">{*(clang::NamedDecl *)(Ptr&amp;~Mask)}</DisplayString>
<DisplayString>{*this,view(access)} {*this,view(decl)}</DisplayString>
DeclAccessPair visualizer should be expandable llvm-svn: 350167
2018-12-31 04:22:37 +08:00
<Expand>
<Item Name="access">(clang::AccessSpecifier)(Ptr&amp;Mask),en</Item>
<Item Name="decl">*(clang::NamedDecl *)(Ptr&amp;~Mask)</Item>
</Expand>
Visual Studio visualizers associated with LookupResults Visualizers for DeclAccessPair, UnresolvedSet, and LookupResult. For example, when combined with LLVM diff D21256 (currently in review), a Lookup set will show much more naturally in the Locals window something like Found: {public typename ...Ts} llvm-svn: 272448
2016-06-11 11:02:33 +08:00
</Type>
Various improvements to Clang MSVC Visualizer This change adds/improves MSVC visualizers for many Clang types, including array types, trailing return types in function, deduction guides, a fix for OpaquePtr, etc. It also replaces all of the view(deref) with the "na" formatter, which is a better built-in natvis technique for doing the same thing. Differential Revision: https://reviews.llvm.org/D63039 llvm-svn: 363574
2019-06-18 00:12:45 +08:00
<Type Name="clang::UnqualifiedId">
<DisplayString Condition="Kind==UnqualifiedIdKind::IK_Identifier">[IK_Identifier] {*Identifier}</DisplayString>
<DisplayString Condition="Kind==UnqualifiedIdKind::IK_OperatorFunctionId">[IK_OperatorFunctionId] {OperatorFunctionId}</DisplayString>
<DisplayString Condition="Kind==UnqualifiedIdKind::IK_ConversionFunctionId">[IK_ConversionFunctionId] {ConversionFunctionId}</DisplayString>
<DisplayString Condition="Kind==UnqualifiedIdKind::IK_ConstructorName">[IK_ConstructorName] {ConstructorName}</DisplayString>
<DisplayString Condition="Kind==UnqualifiedIdKind::IK_DestructorName">[IK_DestructorName] {DestructorName}</DisplayString>
<DisplayString Condition="Kind==UnqualifiedIdKind::IK_DeductionGuideName">[IK_DeductionGuideName] {TemplateName}</DisplayString>
<DisplayString Condition="Kind==UnqualifiedIdKind::IK_TemplateId">[IK_TemplateId] {TemplateId}</DisplayString>
<DisplayString Condition="Kind==UnqualifiedIdKind::IK_ConstructorTemplateId">[IK_ConstructorTemplateId] {TemplateId}</DisplayString>
<DisplayString>Kind</DisplayString>
<Expand>
<ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_Identifier">Identifier</ExpandedItem>
<ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_OperatorFunctionId">OperatorFunctionId</ExpandedItem>
<ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_ConversionFunctionId">ConversionFunctionId</ExpandedItem>
<ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_ConstructorName">ConstructorName</ExpandedItem>
<ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_DestructorName">DestructorName</ExpandedItem>
<ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_DeductionGuideName">TemplateName</ExpandedItem>
<ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_TemplateId">TemplateId</ExpandedItem>
<ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_ConstructorTemplateId">TemplateId</ExpandedItem>
</Expand>
</Type>
<Type Name="clang::DeclGroup">
<DisplayString>NumDecls={NumDecls}</DisplayString>
<Expand>
<ArrayItems>
<Size>NumDecls</Size>
<ValuePointer>(Decl **)(this+1)</ValuePointer>
</ArrayItems>
</Expand>
</Type>
<Type Name="clang::DeclGroupRef">
<DisplayString Condition="(Kind)((uintptr_t)D&amp;1)==SingleDeclKind">{*D}</DisplayString>
<DisplayString>{*(DeclGroup *)((uintptr_t)D&amp;~1)}</DisplayString>
<Expand>
<ExpandedItem Condition="(Kind)((uintptr_t)D&amp;1)==SingleDeclKind">D</ExpandedItem>
<ExpandedItem Condition="(Kind)((uintptr_t)D&amp;1)==DeclGroupKind">(DeclGroup *)((uintptr_t)D&amp;~1)</ExpandedItem>
</Expand>
</Type>
<Type Name="clang::Declarator">
<DisplayString>{DS} {Name}</DisplayString>
</Type>
Visual Studio visualizers associated with LookupResults Visualizers for DeclAccessPair, UnresolvedSet, and LookupResult. For example, when combined with LLVM diff D21256 (currently in review), a Lookup set will show much more naturally in the Locals window something like Found: {public typename ...Ts} llvm-svn: 272448
2016-06-11 11:02:33 +08:00
<Type Name="clang::UnresolvedSet&lt;*&gt;">
<DisplayString>{Decls}</DisplayString>
<Expand>
<ExpandedItem>Decls</ExpandedItem>
</Expand>
</Type>
<Type Name="clang::LookupResult">
<DisplayString Condition="ResultKind == clang::LookupResult::Ambiguous">{Ambiguity,en}: {Decls}</DisplayString>
<DisplayString>{ResultKind,en}: {Decls}</DisplayString>
</Type>
Fix MSVC visualizations for ActionResult and OpaquePtr Mainly just fixing buggy code. Also removed unnecessary visualizers for specializations of OpaquePtr llvm-svn: 350371
2019-01-04 07:24:39 +08:00
<Type Name="clang::ActionResult&lt;*, 0&gt;">
Visual Studio Visualizers for ActionResult, LocInfoType, and and TypeSourceInfo Created a visualizer for ActionResult that displayed the validity and the pointer, but many of them initially displayed poorly. It turns out that the primary culprit is that LocInfoType is often passed in an action result, but it is not the same as other types. For example, LocInfoType is not in TypeNodes.def and clang::Type::TypeClass does not have a LocInfoType enum. After adding a special visualizer for LocInfoType, the display was more useful llvm-svn: 272487
2016-06-12 04:15:19 +08:00
<DisplayString Condition="Invalid">Invalid</DisplayString>
Fix MSVC visualizations for ActionResult and OpaquePtr Mainly just fixing buggy code. Also removed unnecessary visualizers for specializations of OpaquePtr llvm-svn: 350371
2019-01-04 07:24:39 +08:00
<DisplayString Condition="!*(void **)&amp;Val">Unset</DisplayString>
<DisplayString>{Val}</DisplayString>
Visual Studio Visualizers for ActionResult, LocInfoType, and and TypeSourceInfo Created a visualizer for ActionResult that displayed the validity and the pointer, but many of them initially displayed poorly. It turns out that the primary culprit is that LocInfoType is often passed in an action result, but it is not the same as other types. For example, LocInfoType is not in TypeNodes.def and clang::Type::TypeClass does not have a LocInfoType enum. After adding a special visualizer for LocInfoType, the display was more useful llvm-svn: 272487
2016-06-12 04:15:19 +08:00
</Type>
Fix MSVC visualizations for ActionResult and OpaquePtr Mainly just fixing buggy code. Also removed unnecessary visualizers for specializations of OpaquePtr llvm-svn: 350371
2019-01-04 07:24:39 +08:00
<Type Name="clang::ActionResult&lt;*, 1&gt;">
<DisplayString Condition="PtrWithInvalid&amp;1">Invalid</DisplayString>
<DisplayString Condition="!PtrWithInvalid">Unset</DisplayString>
<DisplayString>{($T1)(PtrWithInvalid&amp;~1)}</DisplayString>
Visual Studio Visualizers for ActionResult, LocInfoType, and and TypeSourceInfo Created a visualizer for ActionResult that displayed the validity and the pointer, but many of them initially displayed poorly. It turns out that the primary culprit is that LocInfoType is often passed in an action result, but it is not the same as other types. For example, LocInfoType is not in TypeNodes.def and clang::Type::TypeClass does not have a LocInfoType enum. After adding a special visualizer for LocInfoType, the display was more useful llvm-svn: 272487
2016-06-12 04:15:19 +08:00
<Expand>
<Item Name="Invalid">(bool)(PtrWithInvalid&amp;1)</Item>
Fix MSVC visualizations for ActionResult and OpaquePtr Mainly just fixing buggy code. Also removed unnecessary visualizers for specializations of OpaquePtr llvm-svn: 350371
2019-01-04 07:24:39 +08:00
<Item Name="Val">($T1)(PtrWithInvalid&amp;~1)</Item>
Visual Studio Visualizers for ActionResult, LocInfoType, and and TypeSourceInfo Created a visualizer for ActionResult that displayed the validity and the pointer, but many of them initially displayed poorly. It turns out that the primary culprit is that LocInfoType is often passed in an action result, but it is not the same as other types. For example, LocInfoType is not in TypeNodes.def and clang::Type::TypeClass does not have a LocInfoType enum. After adding a special visualizer for LocInfoType, the display was more useful llvm-svn: 272487
2016-06-12 04:15:19 +08:00
</Expand>
</Type>
Since Visual Studio 2012 is the minimum version of MSVC we support, the old-style visualizers are being removed. Adding a Natvis replacement for the debugging visualizers. llvm-svn: 200032
2014-01-25 03:46:45 +08:00
</AutoVisualizer>