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

503 lines
35 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.
-->
<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>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Attributed" IncludeView="poly">{*(clang::AttributedType *)this}</DisplayString>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::TemplateTypeParm" IncludeView="poly">{*(clang::TemplateTypeParmType *)this}</DisplayString>
<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>
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 Condition="TypeBits.TC==clang::Type::TypeClass::FunctionProto" IncludeView="poly">{*(clang::FunctionProtoType *)this}</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>
<DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::InjectedClassName" IncludeView="poly">{*(clang::InjectedClassNameType *)this}</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="cpp">{*this,view(poly)}</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 IncludeView="poly">{*this,view(cmn)}</DisplayString> <!-- Not yet implemented Type subclass -->
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>
<Item Name="Flags" IncludeView="cmn">TypeBits</Item>
<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>
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::Attributed">*(clang::AttributedType *)this</ExpandedItem>
<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>
<ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::InjectedClassName">(clang::InjectedClassNameType *)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>
<Type Name="clang::PointerType">
<DisplayString>{PointeeType, view(poly)} *</DisplayString>
<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">
<DisplayString>{(clang::Decl::Kind)DeclKind,en}Decl</DisplayString>
<Expand>
<Item Name="DeclKind">(clang::Decl::Kind)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>
<DisplayString IncludeView="MaybeEllipses" Condition="((TemplateTypeParmType *)TypeForDecl)->CanTTPTInfo.ParameterPack">...</DisplayString>
<DisplayString IncludeView="MaybeEllipses" Condition="!((TemplateTypeParmType *)TypeForDecl)->CanTTPTInfo.ParameterPack"></DisplayString>
<DisplayString>{*this,view(TorC)} {*this,view(MaybeEllipses)}{Name,view(cpp)}</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">
<DisplayString>template{*TemplateParams} {*TemplatedDecl};</DisplayString>
</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>
<DisplayString IncludeView="modifiers">{*this,view(implicit)}</DisplayString>
<DisplayString IncludeView="cpp">{*this,view(modifiers)}{Name,view(cpp)}</DisplayString>
<DisplayString Condition="TagDeclKind==clang::TagTypeKind::TTK_Struct">{*this,view(modifiers)}struct {Name,view(cpp)}</DisplayString>
<DisplayString Condition="TagDeclKind==clang::TagTypeKind::TTK_Interface">{*this,view(modifiers)}interface {Name,view(cpp)}</DisplayString>
<DisplayString Condition="TagDeclKind==clang::TagTypeKind::TTK_Union">{*this,view(modifiers)}union {Name,view(cpp)}</DisplayString>
<DisplayString Condition="TagDeclKind==clang::TagTypeKind::TTK_Class">{*this,view(modifiers)}class {Name,view(cpp)}</DisplayString>
<DisplayString Condition="TagDeclKind==clang::TagTypeKind::TTK_Enum">{*this,view(modifiers)}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">
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">{*decl,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
<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">
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::TagType *)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>{*(clang::TagType *)this}</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">
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>{*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">
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="retType">{ResultType,view(cpp)}</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" Condition="NumParams==0"></DisplayString>
<DisplayString IncludeView="parm0">{*(clang::QualType *)(this+1),view(cpp)}{*this,view(parm1)}</DisplayString>
<DisplayString IncludeView="parm1" Condition="NumParams==1"></DisplayString>
<DisplayString IncludeView="parm1">, {*((clang::QualType *)(this+1)+1),view(cpp)}{*this,view(parm2)}</DisplayString>
<DisplayString IncludeView="parm2" Condition="NumParams==2"></DisplayString>
<DisplayString IncludeView="parm2">, {*((clang::QualType *)(this+1)+2),view(cpp)}{*this,view(parm3)}</DisplayString>
<DisplayString IncludeView="parm3" Condition="NumParams==3"></DisplayString>
<DisplayString IncludeView="parm3">, {*((clang::QualType *)(this+1)+3),view(cpp)}{*this,view(parm4)}</DisplayString>
<DisplayString IncludeView="parm4" Condition="NumParams==4"></DisplayString>
<DisplayString IncludeView="parm4">, {*((clang::QualType *)(this+1)+4),view(cpp)}{*this,view(parm5)}</DisplayString>
<DisplayString IncludeView="parm5" Condition="NumParams==5"></DisplayString>
<DisplayString IncludeView="parm5">, /* expand for more params */</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>{*this,view(retType)}({*this,view(parm0)})</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>
<Item Name="ReturnType">ResultType</Item>
<Synthetic Name="Parameter Types">
<DisplayString>{*this,view(parm0)}</DisplayString>
<Expand>
<ArrayItems>
<Size>NumParams</Size>
<ValuePointer>(clang::QualType *)(this+1)</ValuePointer>
</ArrayItems>
</Expand>
</Synthetic>
<ExpandedItem>*(clang::Type *)this, view(cmn)</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">
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
<DisplayString IncludeView="cpp">{*TTPDecl,view(cpp)}</DisplayString>
<DisplayString>{*TTPDecl}</DisplayString>
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">
<DisplayString>{*Decl,view(cpp)}</DisplayString>
<Expand>
<Item Name="Decl">Decl</Item>
<Item Name="InjectedType">InjectedType</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>
<!-- 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>
<DisplayString>{*((clang::ExtQualsTypeCommonBase *)(((uintptr_t)Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType}{*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>
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="BaseType">*((clang::ExtQualsTypeCommonBase *)(((uintptr_t)Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType</Item>
</Expand>
</Type>
<Type Name="clang::TemplateArgumentLoc">
<DisplayString>{Argument}</DisplayString>
<Expand>
<ExpandedItem>Argument</ExpandedItem>
</Expand>
</Type>
<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>
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>
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>
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>
</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>
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">
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" Condition="NumArgs==0"></DisplayString>
<DisplayString IncludeView="arg0">{((clang::TemplateArgument *)(this+1))[0],view(cpp)}{*this,view(arg1)}</DisplayString>
<DisplayString IncludeView="arg1" Condition="NumArgs==1"></DisplayString>
<DisplayString IncludeView="arg1">, {((clang::TemplateArgument *)(this+1))[1],view(cpp)}{*this,view(arg2)}</DisplayString>
<DisplayString IncludeView="arg2" Condition="NumArgs==2"></DisplayString>
<DisplayString IncludeView="arg2">, {((clang::TemplateArgument *)(this+1))[2],view(cpp)}{*this,view(arg3)}</DisplayString>
<DisplayString Condition="(Template.Storage.Val.Val.Value &amp; 3) == 0">
{*((clang::TemplateDecl *)((Template.Storage.Val.Val.Value &gt;&gt; 2) &lt;&lt; 2))->TemplatedDecl,view(cpp)}&lt;{*this,view(arg0)}&gt;
</DisplayString>
<Expand>
<Item Name="Template">Template.Storage</Item>
<ArrayItems>
<Size>NumArgs</Size>
<ValuePointer>(clang::TemplateArgument *)(this+1)</ValuePointer>
</ArrayItems>
</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>
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>
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"
IncludeView="cpp">{*(clang::DeclarationNameExtra *)(Ptr &amp; ~PtrMask),view(cpp)}</DisplayString>
<DisplayString Condition="(Ptr &amp; PtrMask) == StoredDeclarationNameExtra">{{Extra ({*(clang::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>
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 Condition="(Ptr &amp; PtrMask) == StoredIdentifier" Name="[Identifier]">*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)</Item>
<Item Condition="(Ptr &amp; PtrMask) == StoredObjCZeroArgSelector" Name="[ObjC Zero Arg Selector]">*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)</Item>
<Item Condition="(Ptr &amp; PtrMask) == StoredObjCOneArgSelector" Name="[ObjC One Arg Selector]">*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)</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
<Item Condition="(Ptr &amp; PtrMask) == StoredDeclarationNameExtra" Name="[Extra]">(clang::DeclarationNameExtra *)(Ptr &amp; ~PtrMask)</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>
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 Name="clang::DeclarationNameExtra">
<DisplayString IncludeView="cpp"
Condition="ExtraKindOrNumArgs &gt;= clang::DeclarationNameExtra::CXXConstructor
&amp;&amp; ExtraKindOrNumArgs &lt;= clang::DeclarationNameExtra::CXXConversionFunction"
>{((clang::CXXSpecialName *)this)-&gt;Type,view(cpp)}</DisplayString>
<DisplayString>{(clang::DeclarationNameExtra::ExtraKind)ExtraKindOrNumArgs,en}{" ",sb}{*this,view(cpp)}</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::Token">
<DisplayString Condition="Kind != clang::tok::identifier">{(clang::tok::TokenKind)Kind,en}</DisplayString>
<DisplayString Condition="Kind == clang::tok::identifier">{{Identifier ({*(clang::IdentifierInfo *)(PtrData)})}}</DisplayString>
</Type>
<Type Name="clang::DeclSpec">
<DisplayString>[{(clang::DeclSpec::SCS)StorageClassSpec}], [{(clang::TypeSpecifierType)TypeSpecType}]</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
</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">
<DisplayString>{DeclType,view(cpp)} {Name,view(cpp)}</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">
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>{*(DeclaratorDecl*)this,nd}</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>
<ExpandedItem>*(DeclaratorDecl*)this,nd</ExpandedItem>
<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>
<Type Name="clang::FunctionDecl">
<DisplayString IncludeView="retType">{*(clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType,view(retType)}</DisplayString>
<DisplayString IncludeView="parm0" Condition="0 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;NumParams"></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="parm0">{*ParamInfo[0]}{*this,view(parm1)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
<DisplayString IncludeView="parm1" Condition="1 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;NumParams"></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="parm1">, {*ParamInfo[1]}{*this,view(parm2)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
<DisplayString IncludeView="parm2" Condition="2 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;NumParams"></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="parm2">, {*ParamInfo[2]}{*this,view(parm3)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
<DisplayString IncludeView="parm3" Condition="3 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;NumParams"></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="parm3">, {*ParamInfo[3]}{*this,view(parm4)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
<DisplayString IncludeView="parm4" Condition="4 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;NumParams"></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="parm4">, {*ParamInfo[4]}{*this,view(parm5)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
<DisplayString IncludeView="parm5" Condition="5 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;NumParams"></DisplayString>
<DisplayString IncludeView="parm5">, /* expand for more params */</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>{*this,view(retType)nd} {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>
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
<Item Name="ReturnType">*this,view(retType)nd</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>
<Size>((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;NumParams</Size>
<ValuePointer>ParamInfo</ValuePointer>
</ArrayItems>
</Expand>
</Synthetic>
<ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
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;">
Added missing close brace to OpaquePtr Visual Studio visualizer This syntax error resulted in garbage being appended to OpaquePtr visualizations llvm-svn: 272441
2016-06-11 06:25:43 +08:00
<DisplayString>{($T1 *)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>
<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>
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>
<DisplayString IncludeView="access" Condition="(Ptr&amp;Mask) == clang::AS_none">b</DisplayString>
<DisplayString IncludeView="decl">{*(clang::NamedDecl *)(Ptr&amp;~Mask)}</DisplayString>
<DisplayString>{*this,view(access)} {*this,view(decl)}</DisplayString>
</Type>
<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>
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>