JetBrains.ReSharper.Cpp ClangTidy Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected. pXqD##80BM pX--.'''BM pX--.'''BM pX--.'''BM pX--.'''BM ^pX--.'''BM/ ?wT_--.'''^iWV 4w``--.''''_W$ 4wpXqD##80BMW$ ,Sp+ `````` .BX '*apT` ``````` BB "=LlP4|^` ``.'````` -Bq ek=_. ```+{`````` *Bv \4_ -=aP'````` _#8` fh*` `^fOR{` `+Dq' ~5wbpXOqRRRD###88qc` For details on Themed Icons and their use, see Remarks on the outer class. <Image Source="{icons:ThemedIcon myres:PopetilThemedIconsThemedIcons+ClangTidy}" /> <!-- XAML --> [Item(Name="Sample", Icon=typeof(PopetilThemedIconsThemedIcons.ClangTidy))] // C# Type attribute IconId iconid = PopetilThemedIconsThemedIcons.ClangTidy.Id; // IconId identifier object themediconmanager.GetIcon<PopetilThemedIconsThemedIcons.ClangTidy>() // Icon image for rendering identifier class Loads the image for Themed Icon ClangTidy theme aspect Color. Loads the image for Themed Icon ClangTidy theme aspect Gray. Loads the image for Themed Icon ClangTidy theme aspect GrayDark. Returns the set of theme images for Themed Icon ClangTidy. Performance Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected. `_~*?T1Cf{) -"\{C7L+=^^=;aa ';slc;,__:,"~^=;P5 ``-'''^Jl+,''__:,"~^==;(PL `=c|?*\LLcL"'''__:~;^^==;;LPP` `zT'``':^===''__:+ePPPY!;+*Sh" Tz``=llllv^__:,"}PPPPP?*LE4= _vT'.+lFc,_:,"~^;zIj{J\?P4= '{C_'___:,"~^==;;+*\L|6V~ cYL'__:,"~^==;;+*\LTSGv` '=T5|=,"~^==;;+*\L?YhGv `^,`:7E1+==;;+*\L725r*b7 =='-` 'zaYc+*\T}Y1Ya:\O+ '+^_'````:vVEj64j!::'_A4- =\~::__:,""~c='_LEHe2pP. *r+;^^:_-` -_- For details on Themed Icons and their use, see Remarks on the outer class. <Image Source="{icons:ThemedIcon myres:PopetilThemedIconsThemedIcons+Performance}" /> <!-- XAML --> [Item(Name="Sample", Icon=typeof(PopetilThemedIconsThemedIcons.Performance))] // C# Type attribute IconId iconid = PopetilThemedIconsThemedIcons.Performance.Id; // IconId identifier object themediconmanager.GetIcon<PopetilThemedIconsThemedIcons.Performance>() // Icon image for rendering identifier class Loads the image for Themed Icon Performance theme aspect Color. Loads the image for Themed Icon Performance theme aspect Gray. Loads the image for Themed Icon Performance theme aspect GrayDark. Returns the set of theme images for Themed Icon Performance. Unreal Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected. .:;e*` :_I8- `:_6u` `*JVpX[?~^_rDTr[hpk}r. `rDE;:.-~Th888847~-.:;2DT` }D*``` ``````` `;De ^mI```-c2j|:`````` ;*\ ``7m! `6w:.. Ykkkkj .. :"--:: ..-Kb. cb*---`-rsz?:`-- n3) .-----;bi `XP:-----````----````.-------j4. !Xc:::::::~rJ2oooo2s?;:::::::\Xr {E;,,,,,\3E7~:-``'-^)kj*_,,,,"Ey /a7^^^=[j=. `;2I\^^^Lac ~v55tT;` ;){55s; For details on Themed Icons and their use, see Remarks on the outer class. <Image Source="{icons:ThemedIcon myres:WexuporThemedIconsThemedIcons+Unreal}" /> <!-- XAML --> [Item(Name="Sample", Icon=typeof(WexuporThemedIconsThemedIcons.Unreal))] // C# Type attribute IconId iconid = WexuporThemedIconsThemedIcons.Unreal.Id; // IconId identifier object themediconmanager.GetIcon<WexuporThemedIconsThemedIcons.Unreal>() // Icon image for rendering CppModule Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected. `._~!r)iii)r!~_.` .,~;,'``````.-,~!r=,. .,,"- ```..--,~/c;,. `.,;- "7|c, ``.'-!xoy*-~c~.` -~_.` "iT);:-`.-^\Tuak*'~r!~- _r,` ^l7|)c^`-_+1ueVh+'"/+r_ "i^ ~tiTL+~_"~+JIVEX+-,=ri" "i~```={li+^!cT7?/JEh6r-"=ri" _r^..`=xFt;'/55ar_rKhX+-"!\r_ -~^"_.!uI]!.=li7/"cEU6r-~r!~- `.^+=,r5oI!-~rr+!=TEU4?-=c~.` .,=r/==~==;!!!!!!!/+cT!,. .,;LL?+/!;;;!/+?Lc!,. `._~!r)iii)r!~_.` For details on Themed Icons and their use, see Remarks on the outer class. <Image Source="{icons:ThemedIcon myres:CppThemedIcons+CppModule}" /> <!-- XAML --> [Item(Name="Sample", Icon=typeof(CppThemedIcons.CppModule))] // C# Type attribute IconId iconid = CppThemedIcons.CppModule.Id; // IconId identifier object themediconmanager.GetIcon<CppThemedIcons.CppModule>() // Icon image for rendering CppModule Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected. `._~!r)iii)r!~_.` .,~;,'``````.-,~!r=,. .,,"- ```..--,~/c;,. `.,;- "7|c, ``.'-!xoy*-~c~.` -~_.` "iT);:-`.-^\Tuak*'~r!~- _r,` ^l7|)c^`-_+1ueVh+'"/+r_ "i^ ~tiTL+~_"~+JIVEX+-,=ri" "i~```={li+^!cT7?/JEh6r-"=ri" _r^..`=xFt;'/55ar_rKhX+-"!\r_ -~^"_.!uI]!.=li7/"cEU6r-~r!~- `.^+=,r5oI!-~rr+!=TEU4?-=c~.` .,=r/==~==;!!!!!!!/+cT!,. .,;LL?+/!;;;!/+?Lc!,. `._~!r)iii)r!~_.` For details on Themed Icons and their use, see Remarks on the outer class. <Image Source="{icons:ThemedIcon myres:CppThemedIcons+CppModule}" /> <!-- XAML --> [Item(Name="Sample", Icon=typeof(CppThemedIcons.CppModule))] // C# Type attribute IconId iconid = CppThemedIcons.CppModule.Id; // IconId identifier object themediconmanager.GetIcon<CppThemedIcons.CppModule>() // Icon image for rendering CppModule Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected. `._~!r)iii)r!~_.` .,~;,'``````.-,~!r=,. .,,"- ```..--,~/c;,. `.,;- "7|c, ``.'-!xoy*-~c~.` -~_.` "iT);:-`.-^\Tuak*'~r!~- _r,` ^l7|)c^`-_+1ueVh+'"/+r_ "i^ ~tiTL+~_"~+JIVEX+-,=ri" "i~```={li+^!cT7?/JEh6r-"=ri" _r^..`=xFt;'/55ar_rKhX+-"!\r_ -~^"_.!uI]!.=li7/"cEU6r-~r!~- `.^+=,r5oI!-~rr+!=TEU4?-=c~.` .,=r/==~==;!!!!!!!/+cT!,. .,;LL?+/!;;;!/+?Lc!,. `._~!r)iii)r!~_.` For details on Themed Icons and their use, see Remarks on the outer class. <Image Source="{icons:ThemedIcon myres:CppThemedIcons+CppModule}" /> <!-- XAML --> [Item(Name="Sample", Icon=typeof(CppThemedIcons.CppModule))] // C# Type attribute IconId iconid = CppThemedIcons.CppModule.Id; // IconId identifier object themediconmanager.GetIcon<CppThemedIcons.CppModule>() // Icon image for rendering CppModule Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected. `._~!r)iii)r!~_.` .,~;,'``````.-,~!r=,. .,,"- ```..--,~/c;,. `.,;- "7|c, ``.'-!xoy*-~c~.` -~_.` "iT);:-`.-^\Tuak*'~r!~- _r,` ^l7|)c^`-_+1ueVh+'"/+r_ "i^ ~tiTL+~_"~+JIVEX+-,=ri" "i~```={li+^!cT7?/JEh6r-"=ri" _r^..`=xFt;'/55ar_rKhX+-"!\r_ -~^"_.!uI]!.=li7/"cEU6r-~r!~- `.^+=,r5oI!-~rr+!=TEU4?-=c~.` .,=r/==~==;!!!!!!!/+cT!,. .,;LL?+/!;;;!/+?Lc!,. `._~!r)iii)r!~_.` For details on Themed Icons and their use, see Remarks on the outer class. <Image Source="{icons:ThemedIcon myres:CppThemedIcons+CppModule}" /> <!-- XAML --> [Item(Name="Sample", Icon=typeof(CppThemedIcons.CppModule))] // C# Type attribute IconId iconid = CppThemedIcons.CppModule.Id; // IconId identifier object themediconmanager.GetIcon<CppThemedIcons.CppModule>() // Icon image for rendering Provides compilation properties for a C++ platform which name is hashed for NDA reasons. Test in the platform plugin (search by usages of provider). Added for Guerilla Games. Provides deterministic hash-functions that can be serialized in caches. If subtree rooted at \p node contains any node from macro substitution then it should contain corresponding macro call This does not cause boxing for value types. Useful in generic methods. Providers with (i.e. Unreal Engine) intended to be checked first. Providers with (i.e. Nintendo) intended to be checked before providers with , but after providers. Providers with lower priority executes first This value can not be passed to any function expected CppDependentInfo, It's needed only for compact implementation of CppDependentInfoCachedValue Please check for reasoning why we need XXXWithContext entries. Files having these properties will use the provided compilation flags directly, i.e. they will *not* get any extra flags from the project. These properties are only created in code and never loaded from VS solutions. See CppProjectSnapshot for examples. When present inside `VCXProjectConfiguration`, will be preferred over actual properties written inside it. Returns .Build.cs file which corresponds to the .h/.cpp code file passed as . This .Build.cs file can be either module description or subrule description. If you need to get real module .Build.cs's file call instead but you need enabled for that! If is disabled - acts the same way as . Otherwise: If is a valid subrule file (for instance, PATH/ModuleName_Windows.Build.cs) returns it's base module file (for instance, OTHER_PATH/ModuleName.Build.cs). Otherwise probably is module itself and it will be returned. Returns name of module described by \pre must be called once can be replaced \c ICppExpression or resolved \c ICppResolvedExpression @return \c false iff \code GeneratingImplicitMembersStatus() == CppGeneratigImplicitMembersStatus::None \endcode If traits are deleted If traits are deleted CppLambdaClassResolveEntity returns \c null \return sorted list of non-static fields and anonymous classes \note this function can be free and implemented using function \c GetChildren, but it requires additional allocation of list of class children \return all class members including constructors, destructors, finalizers and conversions \note this function can be free and implemented using function \c GetChildren and methods \c GetConstructors(), \c GetDestructors(), ..., but it requires additional allocation of list of class children \note this function can be free and implemented using function \c GetChildren and methods \c GetConversions(), \c GetDestructors(), but it requires additional allocation of list of class children \note this function can be free and implemented using function \c GetChildren , but it requires additional allocation of list of class children this function can be free and implemented using property SymbolParts, but it requires additional allocation of list of symbols @return int::MaxValue if `this` doesn't have default arguments could be ICppVariableDeclaratorResolveEntity for field or ICppClassResolveEntity/ICppDependentTypeResolveEntity for base BASES ///////////////////////////////////////////////////////////////////////////////////////// TYPE TEMPLATE ARGUMENT //////////////////////////////////////////////////////////////////////// EXPRESSION TEMPLATE ARGUMENT ////////////////////////////////////////////////////////////////// TEMPLATE TEMPLATE ARGUMENT ////////////////////////////////////////////////////////////////// @note must be called when \c ResolveMutex is locked \pre !IsDependent(GetDependentInfo()) May return nullptr if bitfield size presents complicated expression. Use overload if you need precise value Returns true if class is a template or a template substitution @returns \c TriBool::Indeterminate iff \p ent is \c protected and EmbracingClass(\p scope) has dependent bases \brief \@li and \@arg commands \pre ClrCacheIsReady Performs required processing during macro argument substitution into the macro body Performs required processing during substitution of macro invokation with it actual replacement body What does that? Performs required processing during substitution of include directive body Performs required processing during substitution of include directive body Word enumeration harness primarily (and solely, though) by word-index engine Tip of the processing chain actual for the given `CppPreprocessor` instance; PP instances chaining extends this particular (processing) chain also Scratchpad instance; for detailed description see `CppPPScratchpad` `ITokenProcessor` -- abstracts the treatment of every (pre-)processed token before pushing it to the scratchpad; primary goal -- to provide facility for token processing, preserving ability to write-through them instantly reducing the count of the copy of a single particular token `CppPPScratchpad` -- holy grail of the whole PP infrastructure; stores actual sequence of PREPROCESSED tokens; sharing this across `CppPreprocessor` instances allows to perform write-through pushes of preprocessed tokens, avoiding making of copies for every PP in the chain. Owned by the root `CppPreprocessor` instance. Parse simple unnested lists (Commands \@arg and \@li) Advances until meets something that closes one of openCommands [or given number of newlines]. NB: also does not advance through multiline comment postfix at the end of comment. \param openCommands stack of open paired doxygen Commands or HTML tags \param skipNewLineCount number of newlines allowed to skip. -1 stays for infinity. eats newlines and whitespace after it \param newLineCount number of newlines to skip. Must be non-zero. Negative values \return indent of the current token README PLEASE (if you want to make changes in lexer)

There's a duplicated implementation of CppInnerLexer on frontend-side (in kotlin, see CPP-38979). Frontend implementation runs the same tests as backend implementation, so usually when you change something in C# and add test for that, it would fail on frontend. At the moment of writing this comment, frontend tests are NOT included in merge robot, so they can be fixed post facto.

If you make any changes to this implementation, please consider changing frontend implementation as well.
If you are not sure how to do that properly, consider asking in #radler-internal Slack channel.
We have similar comment for frontend implementation.
 Tokens producible by lexer Tokens producible by lexer Do not use directly, only through Temporary transition function, just to keep compatibility with old code during refactorings Do NOT use to convert to size_t. Use only when you don't know target type (or conversions are prohibited). This function checks:
- If integral value is zero
- If boolean value is false
- If enumerator has underlying value is zero
- If designator has zero initializer
- If pointer is not null
- If referenced value is zero
- If object value can be converted to `false` (note: not to 0 or 0u)

This logic is redundant in most cases.

If you just want to evaluate some boolean condition - use or .

If you want to check that some literal has "0" value - you don't need conversions at all.

Moreover, you likely need to check it in specific context (as an index in subscription operator, as an argument passed to somewhere). In those cases you should convert value to specific type (size_t/int/etc..). Otherwise, it's simply incorrect: 0x10000000u is zero when passed as `int` but this function reports false. The same applies to other comparisons with zero.

Having `CppObjectValue` as an input here is even more weird case because of unexpected conversion to `bool`.

Prefer with specified target type and check resulting value.
There are helpers for common types like and See for obsolete explanation. See why it's obsolete. See why it's obsolete. See why it's obsolete. See why it's obsolete. `null` when it's not a pointer operation Same as but knows about origin expression Checks if pragma may not have any args or specification like '#pragma once' where no args allowed \pre IsTypeOrUnknownDependent(\p expr.GetDependentInfo()) concepts which qualifier of mem-access expressions satisfies, see test/data/CodeCompletion/Concepts06.cpp this function can be used for such checks as - `IsDeleted` for special members; - `NeedImplicitDisposable` for class; - ... If a conversion exists, this routine will return the standard conversion sequence required to perform this conversion. Otherwise, this routine will return null. Determines whether there is a user-defined conversion sequence (C++ [over.ics.user]) that converts expression From to the type ToType. If such a conversion exists, User will contain the user-defined conversion sequence that performs such a conversion and this routine will return true. Otherwise, this routine returns false and User is unspecified. \param AllowExplicitConversions true if the conversion should consider C++0x "explicit" conversion functions as well as non-explicit conversion functions (C++0x [class.conv.fct]p2). CompareImplicitConversionSequences - Compare two implicit conversion sequences to determine whether one is better than the other or if they are indistinguishable (C++ 13.3.3.2). DirectBinding - True when this is a reference binding that is a direct binding (C++ [dcl.init.ref]). \brief Whether this is an lvalue reference binding (otherwise, it's an rvalue reference binding). CppStandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3.1.1). A standard conversion sequence contains between zero and three conversions. If a particular conversion is not needed, it will be set to the identity conversion (ICK_Identity). Note that the three conversions are specified as separate members (rather than in an array) so that we can keep the size of a standard conversion sequence to a single word. First -- The first conversion can be an lvalue-to-rvalue conversion, array-to-pointer conversion, or function-to-pointer conversion. Second - The second conversion can be an integral promotion, floating point promotion, integral conversion, floating point conversion, floating-integral conversion, pointer conversion, pointer-to-member conversion, or boolean conversion. Third - The third conversion can be a qualification conversion. \brief Whether this is the deprecated conversion of a string literal to a pointer to non-const character data (C++ 4.2p2). FromType - The type that this conversion is converting from. CppUserDefinedConversionSequence - Represents a user-defined conversion sequence (C++ 13.3.3.1.2). \brief Represents the standard conversion that occurs before the actual user-defined conversion. C++11 13.3.3.1.2p1: If the user-defined conversion is specified by a constructor (12.3.1), the initial standard conversion sequence converts the source type to the type required by the argument of the constructor. If the user-defined conversion is specified by a conversion function (12.3.2), the initial standard conversion sequence converts the source type to the implicit object parameter of the conversion function. NOTE: As an extension we can also store User-defined conversion if conversion sequence is created during direct-initialization. After - Represents the standard conversion that occurs after the actual user-defined conversion. ConvertingFunction - The function that will perform the user-defined conversion. Null if the conversion is an aggregate initialization from an initializer list. Represents an ambiguous user-defined conversion sequence. CppBadConversionSequence - Records information about an invalid conversion sequence. CppImplicitConversionKind - The kind of implicit conversion used to convert an argument to a parameter's type. The enumerator values match with Table 9 of (C++ 13.3.3.1.1) and are listed such that better conversion kinds have smaller values. CppOverloadingCandidate - A single candidate in an overload set (C++ 13.3). FailureKind - The reason why this candidate is not viable. Actually an OverloadFailureKind. Conversions - The conversion sequences used to convert the function arguments to the function parameters Viable - True to indicate that this overload candidate is viable. \brief The number of call arguments that were explicitly provided, to be used while performing partial ordering of function templates. FinalConversion - For a conversion function (where Function is a CXXConversionDecl), the standard conversion that occurs after the call to the overload candidate to convert the result of calling the conversion function to the required type. AddBuiltinOperatorCandidates - Add the appropriate built-in operator overloads to the candidate set (C++ [over.built]), based on the operator @p Op and the arguments given. For example, if the operator is a binary '+', this routine might add "int operator+(int, int)" to cover integer addition. BuiltinCandidateTypeSet - A set of types that will be used for the candidate operator functions for built-in operators (C++ [over.built]). The types are separated into pointer types and enumeration types. Helper class to manage the addition of builtin operator overload candidates. It provides shared state and utility methods used throughout the process, as well as a helper method to add each group of builtin operator overloads from the standard to a candidate set. Extensions for template arguments, parameters etc checks and returns array or single @returns \c null iff \p undeterminedSpecialization is not dependent on \c myPrimaryTemplate @returns \c null iff \p depEnt is not dependent on \c myPrimaryTemplate @returns \c null iff \p resolveEntity is not dependent on \c myPrimaryTemplate @returns \c null iff \p classTemplate is not dependent on \c myPrimaryTemplate @returns \c null iff \p args is not dependent on \c myPrimaryTemplate @returns \c null instead of declarator with type containing substitution failure @return \c true iff function has body visible from \p vp and \p forceChameleonInstantiation == \c true or function really need body (functions with auto return type and constexpr functions) Returns \c true if symbol marked by \c UCLASS Returns \c true if symbol marked by \c USTRUCT Returns \c true if entity marked by \c UENUM Returns \c true if entity marked by \c UINTERFACE Returns \c true if entity is IInterface (which means that it is named correctly and follows specially named entity marked by \c UINTERFACE) Returns \c true if entity marked by \c UFUNCTION Returns \c true if entity marked by \c UFUNCTION Returns \c true if symbol marked by \c UFUNCTION Returns \c true if entity marked by \c UPROPERTY Returns \c true if symbol marked by \c UPROPERTY Returns \c true if entity is declared inside class marked by \c UCLASS Returns \c true if entity is related to some Actor class Returns \c true if entity is related to some Component class true if entity is an UFUNCTION with RPC specifiers (thus definition for this function and declaration of _Implementation method will be generated by UHT) Returns true also when entity is an UFUNCTION with BlueprintNativeEvent specifier! Returns \c true if entity is an \c UFUNCTION with RPC and \c WithValidation specifiers (thus declaration of _Validate method will be generated by UHT) Returns true if entity is generated function (by UHT/R++) and it's naming resembles RPC function. If you need to be sure that it is RPC function - use but it is more expensive. Returns \c true if entity is an \c UFUNCTION with \c BlueprintImplementableEvent specifier (thus definition for this function will be generated by UHT) Returns \c true if entity is an \c UFUNCTION with \c BlueprintCallable specifier Returns \c true if entity is related to UCLASS, USTRUCT or IINTERFACE Returns \c true if making entity final won't break UnrealHeaderTool Tries to find in class declaration of prototype function for specified RPC function target RPC function (for instance, ServerSomething_Validate) if rpcCandidate is indeed RPC function then returns its type. Otherwise - RpcWrapperType.None nullptr if prototype function does not exist, otherwise - prototype UFUNCTION (for instance, ServerSomething) Tries to find in class generated function for specified RPC UFUNCTION target RPC function generated function type to look for nullptr if prototype UFUNCTION is invalid; valid resolve entity - otherwise Returns name of generated function for specified RPC \c UFUNCTION Tries to find UInterface related to IInterface IInterface class resolve entity Resolve Cache nullptr if UInterface does not exist, otherwise - UInterface resolve entity Creates new linkage entity for corresponding RPC function Schedules generation of RPC wrappers and Replication machinery if needed Schedules generation of event executor wrappers if needed Provides set of functions for different class prefixes used by Unreal Engine Reference from #pragma directive to a Cpp symbol. In some dialects like Unity HLSL we have pragmas which references to render function (i.e. '#pragma vertext vert' specifies 'vert' function as a vertex shader). Could be `try`, `_try` or `__try` namespace aliasName = namespaceName; CompareReferenceRelationship - Compare the two types T1 and T2 to determine whether they are reference-related, reference-compatible, reference-compatible with added qualification, or incompatible, for use in C++ initialization by reference (C++ [dcl.ref.init]p4). Neither type can be a reference type, and the first type (T1) is the pointee type of the reference type being initialized. Normalizes and discards calling convention CppReferenceRelation - Expresses the result of comparing two types (cv1 T1 and cv2 T2) to determine their compatibility for the purposes of initialization by reference (C++ [dcl.init.ref]p4). Incompatible - The two types are incompatible, so direct reference binding is not possible. Related - The two types are reference-related, which means that their unqualified forms (T1 and T2) are either the same or T1 is a base class of T2. CompatibleWithAddedQualification - The two types are reference-compatible with added qualification, meaning that they are reference-compatible and the qualifiers on T1 (cv1) are greater than the qualifiers on T2 (cv2). Compatible - The two types are reference-compatible and have equivalent qualifiers (cv1 == cv2). @return CppQualType::NullType() if there is no cached type for @p key Calculates offset of member relative to some class. Works fine with base classes and anonymous nested types. Implementation detail Allows storing and rethrowing exceptions while preserving original stack trace. if the processed header is valid