From cc1fa82c5249523c075502aa42656eab00282346 Mon Sep 17 00:00:00 2001 From: Tanner Gooding Date: Mon, 11 Oct 2021 22:23:02 -0700 Subject: [PATCH] Ensure that all new kinds are being properly handled --- sources/ClangSharp/Cursors/Attrs/Attr.cs | 48 ++++++++++++++++++- sources/ClangSharp/Cursors/Decls/Decl.cs | 9 +++- .../Cursors/Exprs/SYCLUniqueStableNameExpr.cs | 15 ++++++ .../Cursors/Stmts/OMPCanonicalLoop.cs | 13 +++++ .../Cursors/Stmts/OMPDispatchDirective.cs | 13 +++++ .../Cursors/Stmts/OMPInteropDirective.cs | 13 +++++ .../Cursors/Stmts/OMPLoopBasedDirective.cs | 18 +++++++ .../Stmts/OMPLoopTransformationDirective.cs | 14 ++++++ .../Cursors/Stmts/OMPMaskedDirective.cs | 13 +++++ .../Cursors/Stmts/OMPTileDirective.cs | 13 +++++ .../Cursors/Stmts/OMPUnrollDirective.cs | 13 +++++ sources/ClangSharp/Cursors/Stmts/Stmt.cs | 23 +++++++++ sources/ClangSharp/Types/Type.cs | 7 ++- .../Properties/launchSettings.json | 3 +- 14 files changed, 211 insertions(+), 4 deletions(-) create mode 100644 sources/ClangSharp/Cursors/Exprs/SYCLUniqueStableNameExpr.cs create mode 100644 sources/ClangSharp/Cursors/Stmts/OMPCanonicalLoop.cs create mode 100644 sources/ClangSharp/Cursors/Stmts/OMPDispatchDirective.cs create mode 100644 sources/ClangSharp/Cursors/Stmts/OMPInteropDirective.cs create mode 100644 sources/ClangSharp/Cursors/Stmts/OMPLoopBasedDirective.cs create mode 100644 sources/ClangSharp/Cursors/Stmts/OMPLoopTransformationDirective.cs create mode 100644 sources/ClangSharp/Cursors/Stmts/OMPMaskedDirective.cs create mode 100644 sources/ClangSharp/Cursors/Stmts/OMPTileDirective.cs create mode 100644 sources/ClangSharp/Cursors/Stmts/OMPUnrollDirective.cs diff --git a/sources/ClangSharp/Cursors/Attrs/Attr.cs b/sources/ClangSharp/Cursors/Attrs/Attr.cs index b6b7fe23..de7e31d6 100644 --- a/sources/ClangSharp/Cursors/Attrs/Attr.cs +++ b/sources/ClangSharp/Cursors/Attrs/Attr.cs @@ -17,7 +17,10 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) internal static new Attr Create(CXCursor handle) => handle.AttrKind switch { + CX_AttrKind.CX_AttrKind_Invalid => new Attr(handle), CX_AttrKind.CX_AttrKind_AddressSpace => new TypeAttr(handle), + CX_AttrKind.CX_AttrKind_ArmMveStrictPolymorphism => new TypeAttr(handle), + CX_AttrKind.CX_AttrKind_CmseNSCall => new TypeAttr(handle), CX_AttrKind.CX_AttrKind_NoDeref => new TypeAttr(handle), CX_AttrKind.CX_AttrKind_ObjCGC => new TypeAttr(handle), CX_AttrKind.CX_AttrKind_ObjCInertUnsafeUnretained => new TypeAttr(handle), @@ -25,6 +28,8 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_OpenCLConstantAddressSpace => new TypeAttr(handle), CX_AttrKind.CX_AttrKind_OpenCLGenericAddressSpace => new TypeAttr(handle), CX_AttrKind.CX_AttrKind_OpenCLGlobalAddressSpace => new TypeAttr(handle), + CX_AttrKind.CX_AttrKind_OpenCLGlobalDeviceAddressSpace => new TypeAttr(handle), + CX_AttrKind.CX_AttrKind_OpenCLGlobalHostAddressSpace => new TypeAttr(handle), CX_AttrKind.CX_AttrKind_OpenCLLocalAddressSpace => new TypeAttr(handle), CX_AttrKind.CX_AttrKind_OpenCLPrivateAddressSpace => new TypeAttr(handle), CX_AttrKind.CX_AttrKind_Ptr32 => new TypeAttr(handle), @@ -33,9 +38,15 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_TypeNonNull => new TypeAttr(handle), CX_AttrKind.CX_AttrKind_TypeNullUnspecified => new TypeAttr(handle), CX_AttrKind.CX_AttrKind_TypeNullable => new TypeAttr(handle), + CX_AttrKind.CX_AttrKind_TypeNullableResult => new TypeAttr(handle), CX_AttrKind.CX_AttrKind_UPtr => new TypeAttr(handle), CX_AttrKind.CX_AttrKind_FallThrough => new StmtAttr(handle), + CX_AttrKind.CX_AttrKind_Likely => new StmtAttr(handle), + CX_AttrKind.CX_AttrKind_MustTail => new StmtAttr(handle), + CX_AttrKind.CX_AttrKind_OpenCLUnrollHint => new StmtAttr(handle), CX_AttrKind.CX_AttrKind_Suppress => new StmtAttr(handle), + CX_AttrKind.CX_AttrKind_Unlikely => new StmtAttr(handle), + CX_AttrKind.CX_AttrKind_NoMerge => new DeclOrStmtAttr(handle), CX_AttrKind.CX_AttrKind_AArch64VectorPcs => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_AcquireHandle => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_AnyX86NoCfCheck => new InheritableAttr(handle), @@ -52,10 +63,12 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_PreserveMost => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_RegCall => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_StdCall => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_SwiftAsyncCall => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_SwiftCall => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_SysVABI => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_ThisCall => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_VectorCall => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_SwiftAsyncContext => new ParameterABIAttr(handle), CX_AttrKind.CX_AttrKind_SwiftContext => new ParameterABIAttr(handle), CX_AttrKind.CX_AttrKind_SwiftErrorResult => new ParameterABIAttr(handle), CX_AttrKind.CX_AttrKind_SwiftIndirectResult => new ParameterABIAttr(handle), @@ -79,6 +92,7 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_AcquiredAfter => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_AcquiredBefore => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_AlignMac68k => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_AlignNatural => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Aligned => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_AllocAlign => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_AllocSize => new InheritableAttr(handle), @@ -89,15 +103,18 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_AnyX86NoCallerSavedRegisters => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_ArcWeakrefUnavailable => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_ArgumentWithTypeTag => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_ArmBuiltinAlias => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Artificial => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_AsmLabel => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_AssertCapability => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_AssertExclusiveLock => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_AssertSharedLock => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_AssumeAligned => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_Assumption => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Availability => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_BPFPreserveAccessIndex => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Blocks => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_Builtin => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_C11NoReturn => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_CFAuditedTransfer => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_CFGuard => new InheritableAttr(handle), @@ -109,6 +126,8 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_CPUSpecific => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_CUDAConstant => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_CUDADevice => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_CUDADeviceBuiltinSurfaceType => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_CUDADeviceBuiltinTextureType => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_CUDAGlobal => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_CUDAHost => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_CUDAInvalidTarget => new InheritableAttr(handle), @@ -120,6 +139,7 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_Capability => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_CapturedRecord => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Cleanup => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_CmseNSEntry => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_CodeSeg => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Cold => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Common => new InheritableAttr(handle), @@ -140,6 +160,8 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_DisableTailCalls => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_EmptyBases => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_EnableIf => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_EnforceTCB => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_EnforceTCBLeaf => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_EnumExtensibility => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_ExcludeFromExplicitInstantiation => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_ExclusiveTrylockFunction => new InheritableAttr(handle), @@ -152,6 +174,7 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_GNUInline => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_GuardedBy => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_GuardedVar => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_HIPManaged => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Hot => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_IBAction => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_IBOutlet => new InheritableAttr(handle), @@ -160,8 +183,10 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_InternalLinkage => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_LTOVisibilityPublic => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_LayoutVersion => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_Leaf => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_LockReturned => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_LocksExcluded => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_M68kInterrupt => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_MIGServerRoutine => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_MSAllocator => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_MSInheritance => new InheritableAttr(handle), @@ -179,6 +204,7 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_MipsLongCall => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_MipsShortCall => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_NSConsumesSelf => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_NSErrorDomain => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_NSReturnsAutoreleased => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_NSReturnsNotRetained => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Naked => new InheritableAttr(handle), @@ -191,6 +217,7 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_NoInstrumentFunction => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_NoMicroMips => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_NoMips16 => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_NoProfileFunction => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_NoReturn => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_NoSanitize => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_NoSpeculativeLoadHardening => new InheritableAttr(handle), @@ -227,7 +254,6 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_ObjCSubclassingRestricted => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_OpenCLIntelReqdSubGroupSize => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_OpenCLKernel => new InheritableAttr(handle), - CX_AttrKind.CX_AttrKind_OpenCLUnrollHint => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_OptimizeNone => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Override => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Owner => new InheritableAttr(handle), @@ -241,6 +267,7 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_PragmaClangRelroSection => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_PragmaClangRodataSection => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_PragmaClangTextSection => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_PreferredName => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_PtGuardedBy => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_PtGuardedVar => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Pure => new InheritableAttr(handle), @@ -250,6 +277,7 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_ReqdWorkGroupSize => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_RequiresCapability => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Restrict => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_Retain => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_ReturnTypestate => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_ReturnsNonNull => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_ReturnsTwice => new InheritableAttr(handle), @@ -261,6 +289,18 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_SetTypestate => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_SharedTrylockFunction => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_SpeculativeLoadHardening => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_StandaloneDebug => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_StrictFP => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_SwiftAsync => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_SwiftAsyncError => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_SwiftAsyncName => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_SwiftAttr => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_SwiftBridge => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_SwiftBridgedTypedef => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_SwiftError => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_SwiftName => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_SwiftNewType => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_SwiftPrivate => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_TLSModel => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Target => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_TestTypestate => new InheritableAttr(handle), @@ -273,6 +313,7 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_Uninitialized => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Unused => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Used => new InheritableAttr(handle), + CX_AttrKind.CX_AttrKind_UsingIfExists => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_Uuid => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_VecReturn => new InheritableAttr(handle), CX_AttrKind.CX_AttrKind_VecTypeHint => new InheritableAttr(handle), @@ -292,8 +333,11 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_AbiTag => new Attr(handle), CX_AttrKind.CX_AttrKind_Alias => new Attr(handle), CX_AttrKind.CX_AttrKind_AlignValue => new Attr(handle), + CX_AttrKind.CX_AttrKind_BuiltinAlias => new Attr(handle), + CX_AttrKind.CX_AttrKind_CalledOnce => new Attr(handle), CX_AttrKind.CX_AttrKind_IFunc => new Attr(handle), CX_AttrKind.CX_AttrKind_InitSeg => new Attr(handle), + CX_AttrKind.CX_AttrKind_LoaderUninitialized => new Attr(handle), CX_AttrKind.CX_AttrKind_LoopHint => new Attr(handle), CX_AttrKind.CX_AttrKind_Mode => new Attr(handle), CX_AttrKind.CX_AttrKind_NoBuiltin => new Attr(handle), @@ -307,11 +351,13 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind) CX_AttrKind.CX_AttrKind_ObjCDirect => new Attr(handle), CX_AttrKind.CX_AttrKind_ObjCDirectMembers => new Attr(handle), CX_AttrKind.CX_AttrKind_ObjCNonLazyClass => new Attr(handle), + CX_AttrKind.CX_AttrKind_ObjCNonRuntimeProtocol => new Attr(handle), CX_AttrKind.CX_AttrKind_ObjCRuntimeName => new Attr(handle), CX_AttrKind.CX_AttrKind_ObjCRuntimeVisible => new Attr(handle), CX_AttrKind.CX_AttrKind_OpenCLAccess => new Attr(handle), CX_AttrKind.CX_AttrKind_Overloadable => new Attr(handle), CX_AttrKind.CX_AttrKind_RenderScriptKernel => new Attr(handle), + CX_AttrKind.CX_AttrKind_SwiftObjCMembers => new Attr(handle), CX_AttrKind.CX_AttrKind_Thread => new Attr(handle), _ => new Attr(handle), }; diff --git a/sources/ClangSharp/Cursors/Decls/Decl.cs b/sources/ClangSharp/Cursors/Decls/Decl.cs index 1e4bb76d..901ec1d6 100644 --- a/sources/ClangSharp/Cursors/Decls/Decl.cs +++ b/sources/ClangSharp/Cursors/Decls/Decl.cs @@ -147,6 +147,7 @@ public bool IsStdNamespace internal static new Decl Create(CXCursor handle) => handle.DeclKind switch { + CX_DeclKind.CX_DeclKind_Invalid => new Decl(handle, handle.kind, handle.DeclKind), CX_DeclKind.CX_DeclKind_AccessSpec => new AccessSpecDecl(handle), CX_DeclKind.CX_DeclKind_Block => new BlockDecl(handle), CX_DeclKind.CX_DeclKind_Captured => new CapturedDecl(handle), @@ -158,7 +159,10 @@ public bool IsStdNamespace CX_DeclKind.CX_DeclKind_Friend => new FriendDecl(handle), CX_DeclKind.CX_DeclKind_FriendTemplate => new FriendTemplateDecl(handle), CX_DeclKind.CX_DeclKind_Import => new ImportDecl(handle), + CX_DeclKind.CX_DeclKind_LifetimeExtendedTemporary => new LifetimeExtendedTemporaryDecl(handle), CX_DeclKind.CX_DeclKind_LinkageSpec => new LinkageSpecDecl(handle), + CX_DeclKind.CX_DeclKind_Using => new UsingDecl(handle), + CX_DeclKind.CX_DeclKind_UsingEnum => new UsingEnumDecl(handle), CX_DeclKind.CX_DeclKind_Label => new LabelDecl(handle), CX_DeclKind.CX_DeclKind_Namespace => new NamespaceDecl(handle), CX_DeclKind.CX_DeclKind_NamespaceAlias => new NamespaceAliasDecl(handle), @@ -187,7 +191,7 @@ public bool IsStdNamespace CX_DeclKind.CX_DeclKind_TypeAlias => new TypeAliasDecl(handle), CX_DeclKind.CX_DeclKind_Typedef => new TypedefDecl(handle), CX_DeclKind.CX_DeclKind_UnresolvedUsingTypename => new UnresolvedUsingTypenameDecl(handle), - CX_DeclKind.CX_DeclKind_Using => new UsingDecl(handle), + CX_DeclKind.CX_DeclKind_UnresolvedUsingIfExists => new UnresolvedUsingIfExistsDecl(handle), CX_DeclKind.CX_DeclKind_UsingDirective => new UsingDirectiveDecl(handle), CX_DeclKind.CX_DeclKind_UsingPack => new UsingPackDecl(handle), CX_DeclKind.CX_DeclKind_UsingShadow => new UsingShadowDecl(handle), @@ -213,8 +217,10 @@ public bool IsStdNamespace CX_DeclKind.CX_DeclKind_VarTemplatePartialSpecialization => new VarTemplatePartialSpecializationDecl(handle), CX_DeclKind.CX_DeclKind_EnumConstant => new EnumConstantDecl(handle), CX_DeclKind.CX_DeclKind_IndirectField => new IndirectFieldDecl(handle), + CX_DeclKind.CX_DeclKind_MSGuid => new MSGuidDecl(handle), CX_DeclKind.CX_DeclKind_OMPDeclareMapper => new OMPDeclareMapperDecl(handle), CX_DeclKind.CX_DeclKind_OMPDeclareReduction => new OMPDeclareReductionDecl(handle), + CX_DeclKind.CX_DeclKind_TemplateParamObject => new TemplateParamObjectDecl(handle), CX_DeclKind.CX_DeclKind_UnresolvedUsingValue => new UnresolvedUsingValueDecl(handle), CX_DeclKind.CX_DeclKind_OMPAllocate => new OMPAllocateDecl(handle), CX_DeclKind.CX_DeclKind_OMPRequires => new OMPRequiresDecl(handle), @@ -222,6 +228,7 @@ public bool IsStdNamespace CX_DeclKind.CX_DeclKind_ObjCPropertyImpl => new ObjCPropertyImplDecl(handle), CX_DeclKind.CX_DeclKind_PragmaComment => new PragmaCommentDecl(handle), CX_DeclKind.CX_DeclKind_PragmaDetectMismatch => new PragmaDetectMismatchDecl(handle), + CX_DeclKind.CX_DeclKind_RequiresExprBody => new RequiresExprBodyDecl(handle), CX_DeclKind.CX_DeclKind_StaticAssert => new StaticAssertDecl(handle), CX_DeclKind.CX_DeclKind_TranslationUnit => new TranslationUnitDecl(handle), _ => new Decl(handle, handle.kind, handle.DeclKind), diff --git a/sources/ClangSharp/Cursors/Exprs/SYCLUniqueStableNameExpr.cs b/sources/ClangSharp/Cursors/Exprs/SYCLUniqueStableNameExpr.cs new file mode 100644 index 00000000..672d4bb6 --- /dev/null +++ b/sources/ClangSharp/Cursors/Exprs/SYCLUniqueStableNameExpr.cs @@ -0,0 +1,15 @@ +// Copyright (c) Microsoft and Contributors. All rights reserved. Licensed under the University of Illinois/NCSA Open Source License. See LICENSE.txt in the project root for license information. + +using System; +using System.Diagnostics; +using ClangSharp.Interop; + +namespace ClangSharp +{ + public sealed class SYCLUniqueStableNameExpr : Expr + { + internal SYCLUniqueStableNameExpr(CXCursor handle) : base(handle, CXCursorKind.CXCursor_UnexposedExpr, CX_StmtClass.CX_StmtClass_SYCLUniqueStableNameExpr) + { + } + } +} diff --git a/sources/ClangSharp/Cursors/Stmts/OMPCanonicalLoop.cs b/sources/ClangSharp/Cursors/Stmts/OMPCanonicalLoop.cs new file mode 100644 index 00000000..e032d0cc --- /dev/null +++ b/sources/ClangSharp/Cursors/Stmts/OMPCanonicalLoop.cs @@ -0,0 +1,13 @@ +// Copyright (c) Microsoft and Contributors. All rights reserved. Licensed under the University of Illinois/NCSA Open Source License. See LICENSE.txt in the project root for license information. + +using ClangSharp.Interop; + +namespace ClangSharp +{ + public sealed class OMPCanonicalLoop : Stmt + { + internal OMPCanonicalLoop(CXCursor handle) : base(handle, CXCursorKind.CXCursor_OMPCanonicalLoop, CX_StmtClass.CX_StmtClass_OMPCanonicalLoop) + { + } + } +} diff --git a/sources/ClangSharp/Cursors/Stmts/OMPDispatchDirective.cs b/sources/ClangSharp/Cursors/Stmts/OMPDispatchDirective.cs new file mode 100644 index 00000000..9578fe9e --- /dev/null +++ b/sources/ClangSharp/Cursors/Stmts/OMPDispatchDirective.cs @@ -0,0 +1,13 @@ +// Copyright (c) Microsoft and Contributors. All rights reserved. Licensed under the University of Illinois/NCSA Open Source License. See LICENSE.txt in the project root for license information. + +using ClangSharp.Interop; + +namespace ClangSharp +{ + public sealed class OMPDispatchDirective : OMPExecutableDirective + { + internal OMPDispatchDirective(CXCursor handle) : base(handle, CXCursorKind.CXCursor_OMPDispatchDirective, CX_StmtClass.CX_StmtClass_OMPDispatchDirective) + { + } + } +} diff --git a/sources/ClangSharp/Cursors/Stmts/OMPInteropDirective.cs b/sources/ClangSharp/Cursors/Stmts/OMPInteropDirective.cs new file mode 100644 index 00000000..6d7378b1 --- /dev/null +++ b/sources/ClangSharp/Cursors/Stmts/OMPInteropDirective.cs @@ -0,0 +1,13 @@ +// Copyright (c) Microsoft and Contributors. All rights reserved. Licensed under the University of Illinois/NCSA Open Source License. See LICENSE.txt in the project root for license information. + +using ClangSharp.Interop; + +namespace ClangSharp +{ + public sealed class OMPInteropDirective : OMPExecutableDirective + { + internal OMPInteropDirective(CXCursor handle) : base(handle, CXCursorKind.CXCursor_OMPInteropDirective, CX_StmtClass.CX_StmtClass_OMPInteropDirective) + { + } + } +} diff --git a/sources/ClangSharp/Cursors/Stmts/OMPLoopBasedDirective.cs b/sources/ClangSharp/Cursors/Stmts/OMPLoopBasedDirective.cs new file mode 100644 index 00000000..87a7eb51 --- /dev/null +++ b/sources/ClangSharp/Cursors/Stmts/OMPLoopBasedDirective.cs @@ -0,0 +1,18 @@ +// Copyright (c) Microsoft and Contributors. All rights reserved. Licensed under the University of Illinois/NCSA Open Source License. See LICENSE.txt in the project root for license information. + +using System; +using ClangSharp.Interop; + +namespace ClangSharp +{ + public class OMPLoopBasedDirective : OMPExecutableDirective + { + private protected OMPLoopBasedDirective(CXCursor handle, CXCursorKind expectedCursorKind, CX_StmtClass expectedStmtClass) : base(handle, expectedCursorKind, expectedStmtClass) + { + if (handle.StmtClass is > CX_StmtClass.CX_StmtClass_LastOMPLoopBasedDirective or < CX_StmtClass.CX_StmtClass_FirstOMPLoopBasedDirective) + { + throw new ArgumentOutOfRangeException(nameof(handle)); + } + } + } +} diff --git a/sources/ClangSharp/Cursors/Stmts/OMPLoopTransformationDirective.cs b/sources/ClangSharp/Cursors/Stmts/OMPLoopTransformationDirective.cs new file mode 100644 index 00000000..c5dc7861 --- /dev/null +++ b/sources/ClangSharp/Cursors/Stmts/OMPLoopTransformationDirective.cs @@ -0,0 +1,14 @@ +// Copyright (c) Microsoft and Contributors. All rights reserved. Licensed under the University of Illinois/NCSA Open Source License. See LICENSE.txt in the project root for license information. + +using System; +using ClangSharp.Interop; + +namespace ClangSharp +{ + public class OMPLoopTransformationDirective : OMPLoopBasedDirective + { + private protected OMPLoopTransformationDirective(CXCursor handle, CXCursorKind expectedCursorKind, CX_StmtClass expectedStmtClass) : base(handle, expectedCursorKind, expectedStmtClass) + { + } + } +} diff --git a/sources/ClangSharp/Cursors/Stmts/OMPMaskedDirective.cs b/sources/ClangSharp/Cursors/Stmts/OMPMaskedDirective.cs new file mode 100644 index 00000000..ef0f36ea --- /dev/null +++ b/sources/ClangSharp/Cursors/Stmts/OMPMaskedDirective.cs @@ -0,0 +1,13 @@ +// Copyright (c) Microsoft and Contributors. All rights reserved. Licensed under the University of Illinois/NCSA Open Source License. See LICENSE.txt in the project root for license information. + +using ClangSharp.Interop; + +namespace ClangSharp +{ + public sealed class OMPMaskedDirective : OMPExecutableDirective + { + internal OMPMaskedDirective(CXCursor handle) : base(handle, CXCursorKind.CXCursor_OMPMaskedDirective, CX_StmtClass.CX_StmtClass_OMPMaskedDirective) + { + } + } +} diff --git a/sources/ClangSharp/Cursors/Stmts/OMPTileDirective.cs b/sources/ClangSharp/Cursors/Stmts/OMPTileDirective.cs new file mode 100644 index 00000000..51b59cbd --- /dev/null +++ b/sources/ClangSharp/Cursors/Stmts/OMPTileDirective.cs @@ -0,0 +1,13 @@ +// Copyright (c) Microsoft and Contributors. All rights reserved. Licensed under the University of Illinois/NCSA Open Source License. See LICENSE.txt in the project root for license information. + +using ClangSharp.Interop; + +namespace ClangSharp +{ + public sealed class OMPTileDirective : OMPLoopTransformationDirective + { + internal OMPTileDirective(CXCursor handle) : base(handle, CXCursorKind.CXCursor_OMPTileDirective, CX_StmtClass.CX_StmtClass_OMPTileDirective) + { + } + } +} diff --git a/sources/ClangSharp/Cursors/Stmts/OMPUnrollDirective.cs b/sources/ClangSharp/Cursors/Stmts/OMPUnrollDirective.cs new file mode 100644 index 00000000..320372f1 --- /dev/null +++ b/sources/ClangSharp/Cursors/Stmts/OMPUnrollDirective.cs @@ -0,0 +1,13 @@ +// Copyright (c) Microsoft and Contributors. All rights reserved. Licensed under the University of Illinois/NCSA Open Source License. See LICENSE.txt in the project root for license information. + +using ClangSharp.Interop; + +namespace ClangSharp +{ + public sealed class OMPUnrollDirective : OMPLoopTransformationDirective + { + internal OMPUnrollDirective(CXCursor handle) : base(handle, CXCursorKind.CXCursor_OMPUnrollDirective, CX_StmtClass.CX_StmtClass_OMPUnrollDirective) + { + } + } +} diff --git a/sources/ClangSharp/Cursors/Stmts/Stmt.cs b/sources/ClangSharp/Cursors/Stmts/Stmt.cs index 9e623017..9e3f8227 100644 --- a/sources/ClangSharp/Cursors/Stmts/Stmt.cs +++ b/sources/ClangSharp/Cursors/Stmts/Stmt.cs @@ -115,6 +115,7 @@ public Stmt StripLabelLikeStatements() internal static new Stmt Create(CXCursor handle) => handle.StmtClass switch { + CX_StmtClass.CX_StmtClass_Invalid => new Stmt(handle, handle.Kind, handle.StmtClass), CX_StmtClass.CX_StmtClass_GCCAsmStmt => new GCCAsmStmt(handle), CX_StmtClass.CX_StmtClass_MSAsmStmt => new MSAsmStmt(handle), CX_StmtClass.CX_StmtClass_BreakStmt => new BreakStmt(handle), @@ -134,20 +135,28 @@ public Stmt StripLabelLikeStatements() CX_StmtClass.CX_StmtClass_IndirectGotoStmt => new IndirectGotoStmt(handle), CX_StmtClass.CX_StmtClass_MSDependentExistsStmt => new MSDependentExistsStmt(handle), CX_StmtClass.CX_StmtClass_NullStmt => new NullStmt(handle), + CX_StmtClass.CX_StmtClass_OMPCanonicalLoop => new OMPCanonicalLoop(handle), CX_StmtClass.CX_StmtClass_OMPAtomicDirective => new OMPAtomicDirective(handle), CX_StmtClass.CX_StmtClass_OMPBarrierDirective => new OMPBarrierDirective(handle), CX_StmtClass.CX_StmtClass_OMPCancelDirective => new OMPCancelDirective(handle), CX_StmtClass.CX_StmtClass_OMPCancellationPointDirective => new OMPCancellationPointDirective(handle), CX_StmtClass.CX_StmtClass_OMPCriticalDirective => new OMPCriticalDirective(handle), + CX_StmtClass.CX_StmtClass_OMPDepobjDirective => new OMPDepobjDirective(handle), + CX_StmtClass.CX_StmtClass_OMPDispatchDirective => new OMPDispatchDirective(handle), CX_StmtClass.CX_StmtClass_OMPFlushDirective => new OMPFlushDirective(handle), + CX_StmtClass.CX_StmtClass_OMPInteropDirective => new OMPInteropDirective(handle), CX_StmtClass.CX_StmtClass_OMPDistributeDirective => new OMPDistributeDirective(handle), CX_StmtClass.CX_StmtClass_OMPDistributeParallelForDirective => new OMPDistributeParallelForDirective(handle), CX_StmtClass.CX_StmtClass_OMPDistributeParallelForSimdDirective => new OMPDistributeParallelForSimdDirective(handle), CX_StmtClass.CX_StmtClass_OMPDistributeSimdDirective => new OMPDistributeSimdDirective(handle), CX_StmtClass.CX_StmtClass_OMPForDirective => new OMPForDirective(handle), CX_StmtClass.CX_StmtClass_OMPForSimdDirective => new OMPForSimdDirective(handle), + CX_StmtClass.CX_StmtClass_OMPMasterTaskLoopDirective => new OMPMasterTaskLoopDirective(handle), + CX_StmtClass.CX_StmtClass_OMPMasterTaskLoopSimdDirective => new OMPMasterTaskLoopSimdDirective(handle), CX_StmtClass.CX_StmtClass_OMPParallelForDirective => new OMPParallelForDirective(handle), CX_StmtClass.CX_StmtClass_OMPParallelForSimdDirective => new OMPParallelForSimdDirective(handle), + CX_StmtClass.CX_StmtClass_OMPParallelMasterTaskLoopDirective => new OMPParallelMasterTaskLoopDirective(handle), + CX_StmtClass.CX_StmtClass_OMPParallelMasterTaskLoopSimdDirective => new OMPParallelMasterTaskLoopSimdDirective(handle), CX_StmtClass.CX_StmtClass_OMPSimdDirective => new OMPSimdDirective(handle), CX_StmtClass.CX_StmtClass_OMPTargetParallelForSimdDirective => new OMPTargetParallelForSimdDirective(handle), CX_StmtClass.CX_StmtClass_OMPTargetSimdDirective => new OMPTargetSimdDirective(handle), @@ -161,10 +170,15 @@ public Stmt StripLabelLikeStatements() CX_StmtClass.CX_StmtClass_OMPTeamsDistributeParallelForDirective => new OMPTeamsDistributeParallelForDirective(handle), CX_StmtClass.CX_StmtClass_OMPTeamsDistributeParallelForSimdDirective => new OMPTeamsDistributeParallelForSimdDirective(handle), CX_StmtClass.CX_StmtClass_OMPTeamsDistributeSimdDirective => new OMPTeamsDistributeSimdDirective(handle), + CX_StmtClass.CX_StmtClass_OMPTileDirective => new OMPTileDirective(handle), + CX_StmtClass.CX_StmtClass_OMPUnrollDirective => new OMPUnrollDirective(handle), + CX_StmtClass.CX_StmtClass_OMPMaskedDirective => new OMPMaskedDirective(handle), CX_StmtClass.CX_StmtClass_OMPMasterDirective => new OMPMasterDirective(handle), CX_StmtClass.CX_StmtClass_OMPOrderedDirective => new OMPOrderedDirective(handle), CX_StmtClass.CX_StmtClass_OMPParallelDirective => new OMPParallelDirective(handle), + CX_StmtClass.CX_StmtClass_OMPParallelMasterDirective => new OMPParallelMasterDirective(handle), CX_StmtClass.CX_StmtClass_OMPParallelSectionsDirective => new OMPParallelSectionsDirective(handle), + CX_StmtClass.CX_StmtClass_OMPScanDirective => new OMPScanDirective(handle), CX_StmtClass.CX_StmtClass_OMPSectionDirective => new OMPSectionDirective(handle), CX_StmtClass.CX_StmtClass_OMPSectionsDirective => new OMPSectionsDirective(handle), CX_StmtClass.CX_StmtClass_OMPSingleDirective => new OMPSingleDirective(handle), @@ -223,6 +237,7 @@ public Stmt StripLabelLikeStatements() CX_StmtClass.CX_StmtClass_CXXNoexceptExpr => new CXXNoexceptExpr(handle), CX_StmtClass.CX_StmtClass_CXXNullPtrLiteralExpr => new CXXNullPtrLiteralExpr(handle), CX_StmtClass.CX_StmtClass_CXXPseudoDestructorExpr => new CXXPseudoDestructorExpr(handle), + CX_StmtClass.CX_StmtClass_CXXRewrittenBinaryOperator => new CXXRewrittenBinaryOperator(handle), CX_StmtClass.CX_StmtClass_CXXScalarValueInitExpr => new CXXScalarValueInitExpr(handle), CX_StmtClass.CX_StmtClass_CXXStdInitializerListExpr => new CXXStdInitializerListExpr(handle), CX_StmtClass.CX_StmtClass_CXXThisExpr => new CXXThisExpr(handle), @@ -238,6 +253,7 @@ public Stmt StripLabelLikeStatements() CX_StmtClass.CX_StmtClass_BuiltinBitCastExpr => new BuiltinBitCastExpr(handle), CX_StmtClass.CX_StmtClass_CStyleCastExpr => new CStyleCastExpr(handle), CX_StmtClass.CX_StmtClass_CXXFunctionalCastExpr => new CXXFunctionalCastExpr(handle), + CX_StmtClass.CX_StmtClass_CXXAddrspaceCastExpr => new CXXAddrspaceCastExpr(handle), CX_StmtClass.CX_StmtClass_CXXConstCastExpr => new CXXConstCastExpr(handle), CX_StmtClass.CX_StmtClass_CXXDynamicCastExpr => new CXXDynamicCastExpr(handle), CX_StmtClass.CX_StmtClass_CXXReinterpretCastExpr => new CXXReinterpretCastExpr(handle), @@ -247,6 +263,7 @@ public Stmt StripLabelLikeStatements() CX_StmtClass.CX_StmtClass_CharacterLiteral => new CharacterLiteral(handle), CX_StmtClass.CX_StmtClass_ChooseExpr => new ChooseExpr(handle), CX_StmtClass.CX_StmtClass_CompoundLiteralExpr => new CompoundLiteralExpr(handle), + CX_StmtClass.CX_StmtClass_ConceptSpecializationExpr => new ConceptSpecializationExpr(handle), CX_StmtClass.CX_StmtClass_ConvertVectorExpr => new ConvertVectorExpr(handle), CX_StmtClass.CX_StmtClass_CoawaitExpr => new CoawaitExpr(handle), CX_StmtClass.CX_StmtClass_CoyieldExpr => new CoyieldExpr(handle), @@ -272,9 +289,12 @@ public Stmt StripLabelLikeStatements() CX_StmtClass.CX_StmtClass_MSPropertyRefExpr => new MSPropertyRefExpr(handle), CX_StmtClass.CX_StmtClass_MSPropertySubscriptExpr => new MSPropertySubscriptExpr(handle), CX_StmtClass.CX_StmtClass_MaterializeTemporaryExpr => new MaterializeTemporaryExpr(handle), + CX_StmtClass.CX_StmtClass_MatrixSubscriptExpr => new MatrixSubscriptExpr(handle), CX_StmtClass.CX_StmtClass_MemberExpr => new MemberExpr(handle), CX_StmtClass.CX_StmtClass_NoInitExpr => new NoInitExpr(handle), CX_StmtClass.CX_StmtClass_OMPArraySectionExpr => new OMPArraySectionExpr(handle), + CX_StmtClass.CX_StmtClass_OMPArrayShapingExpr => new OMPArrayShapingExpr(handle), + CX_StmtClass.CX_StmtClass_OMPIteratorExpr => new OMPIteratorExpr(handle), CX_StmtClass.CX_StmtClass_ObjCArrayLiteral => new ObjCArrayLiteral(handle), CX_StmtClass.CX_StmtClass_ObjCAvailabilityCheckExpr => new ObjCAvailabilityCheckExpr(handle), CX_StmtClass.CX_StmtClass_ObjCBoolLiteralExpr => new ObjCBoolLiteralExpr(handle), @@ -299,6 +319,9 @@ public Stmt StripLabelLikeStatements() CX_StmtClass.CX_StmtClass_ParenListExpr => new ParenListExpr(handle), CX_StmtClass.CX_StmtClass_PredefinedExpr => new PredefinedExpr(handle), CX_StmtClass.CX_StmtClass_PseudoObjectExpr => new PseudoObjectExpr(handle), + CX_StmtClass.CX_StmtClass_RecoveryExpr => new RecoveryExpr(handle), + CX_StmtClass.CX_StmtClass_RequiresExpr => new RequiresExpr(handle), + CX_StmtClass.CX_StmtClass_SYCLUniqueStableNameExpr => new SYCLUniqueStableNameExpr(handle), CX_StmtClass.CX_StmtClass_ShuffleVectorExpr => new ShuffleVectorExpr(handle), CX_StmtClass.CX_StmtClass_SizeOfPackExpr => new SizeOfPackExpr(handle), CX_StmtClass.CX_StmtClass_SourceLocExpr => new SourceLocExpr(handle), diff --git a/sources/ClangSharp/Types/Type.cs b/sources/ClangSharp/Types/Type.cs index 0a917a00..a655dccf 100644 --- a/sources/ClangSharp/Types/Type.cs +++ b/sources/ClangSharp/Types/Type.cs @@ -116,6 +116,7 @@ public Type UnqualifiedDesugaredType internal static Type Create(CXType handle) => handle.TypeClass switch { + CX_TypeClass.CX_TypeClass_Invalid => new Type(handle, handle.kind, handle.TypeClass), CX_TypeClass.CX_TypeClass_Adjusted => new AdjustedType(handle), CX_TypeClass.CX_TypeClass_Decayed => new DecayedType(handle), CX_TypeClass.CX_TypeClass_ConstantArray => new ConstantArrayType(handle), @@ -131,15 +132,19 @@ public Type UnqualifiedDesugaredType CX_TypeClass.CX_TypeClass_Auto => new AutoType(handle), CX_TypeClass.CX_TypeClass_DeducedTemplateSpecialization => new DeducedTemplateSpecializationType(handle), CX_TypeClass.CX_TypeClass_DependentAddressSpace => new DependentAddressSpaceType(handle), + CX_TypeClass.CX_TypeClass_DependentExtInt => new DependentExtIntType(handle), CX_TypeClass.CX_TypeClass_DependentName => new DependentNameType(handle), CX_TypeClass.CX_TypeClass_DependentSizedExtVector => new DependentSizedExtVectorType(handle), CX_TypeClass.CX_TypeClass_DependentTemplateSpecialization => new DependentTemplateSpecializationType(handle), CX_TypeClass.CX_TypeClass_DependentVector => new DependentVectorType(handle), CX_TypeClass.CX_TypeClass_Elaborated => new ElaboratedType(handle), + CX_TypeClass.CX_TypeClass_ExtInt => new ExtIntType(handle), CX_TypeClass.CX_TypeClass_FunctionNoProto => new FunctionNoProtoType(handle), CX_TypeClass.CX_TypeClass_FunctionProto => new FunctionProtoType(handle), CX_TypeClass.CX_TypeClass_InjectedClassName => new InjectedClassNameType(handle), CX_TypeClass.CX_TypeClass_MacroQualified => new MacroQualifiedType(handle), + CX_TypeClass.CX_TypeClass_ConstantMatrix => new ConstantMatrixType(handle), + CX_TypeClass.CX_TypeClass_DependentSizedMatrix => new DependentSizedMatrixType(handle), CX_TypeClass.CX_TypeClass_MemberPointer => new MemberPointerType(handle), CX_TypeClass.CX_TypeClass_ObjCObjectPointer => new ObjCObjectPointerType(handle), CX_TypeClass.CX_TypeClass_ObjCObject => new ObjCObjectType(handle), @@ -164,7 +169,7 @@ public Type UnqualifiedDesugaredType CX_TypeClass.CX_TypeClass_UnresolvedUsing => new UnresolvedUsingType(handle), CX_TypeClass.CX_TypeClass_Vector => new VectorType(handle), CX_TypeClass.CX_TypeClass_ExtVector => new ExtVectorType(handle), - _ => new Type(handle, handle.kind, handle.TypeClass), + _ => new Type(handle, handle.kind, handle.TypeClass), }; public override bool Equals(object obj) => (obj is Type other) && Equals(other); diff --git a/sources/ClangSharpPInvokeGenerator/Properties/launchSettings.json b/sources/ClangSharpPInvokeGenerator/Properties/launchSettings.json index c69b228f..6b3e27d3 100644 --- a/sources/ClangSharpPInvokeGenerator/Properties/launchSettings.json +++ b/sources/ClangSharpPInvokeGenerator/Properties/launchSettings.json @@ -15,7 +15,8 @@ }, "GenerateLocal": { "commandName": "Project", - "commandLineArgs": "-c help" + "commandLineArgs": "@generate.rsp", + "workingDirectory": "C:\\Users\\tagoo\\Source\\repos\\terrafx.interop.windows\\generation\\um\\tpcshrd" } } }