PropertyChainSource

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SourceInfo
{
    public IntPtr FileName;
    public uint LineNumber;
    public uint ColumnNumber;
    public uint CharPosition;
    public IntPtr Hash;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct PropertyChainSource
{
    public ulong Handle;
    public IntPtr TargetType;
    public IntPtr Name;
    public int Source;
    public SourceInfo SrcInfo;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SourceInfo
    Public FileName As IntPtr
    Public LineNumber As UInteger
    Public ColumnNumber As UInteger
    Public CharPosition As UInteger
    Public Hash As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure PropertyChainSource
    Public Handle As ULong
    Public TargetType As IntPtr
    Public Name As IntPtr
    Public Source As Integer
    Public SrcInfo As SourceInfo
End Structure

import ctypes
from ctypes import wintypes

class SourceInfo(ctypes.Structure):
    _fields_ = [
        ("FileName", ctypes.c_void_p),
        ("LineNumber", wintypes.DWORD),
        ("ColumnNumber", wintypes.DWORD),
        ("CharPosition", wintypes.DWORD),
        ("Hash", ctypes.c_void_p),
    ]

class PropertyChainSource(ctypes.Structure):
    _fields_ = [
        ("Handle", ctypes.c_ulonglong),
        ("TargetType", ctypes.c_void_p),
        ("Name", ctypes.c_void_p),
        ("Source", ctypes.c_int),
        ("SrcInfo", SourceInfo),
    ]

#[repr(C)]
pub struct SourceInfo {
    pub FileName: *mut core::ffi::c_void,
    pub LineNumber: u32,
    pub ColumnNumber: u32,
    pub CharPosition: u32,
    pub Hash: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct PropertyChainSource {
    pub Handle: u64,
    pub TargetType: *mut core::ffi::c_void,
    pub Name: *mut core::ffi::c_void,
    pub Source: i32,
    pub SrcInfo: SourceInfo,
}

import "golang.org/x/sys/windows"

type SourceInfo struct {
	FileName uintptr
	LineNumber uint32
	ColumnNumber uint32
	CharPosition uint32
	Hash uintptr
}

type PropertyChainSource struct {
	Handle uint64
	TargetType uintptr
	Name uintptr
	Source int32
	SrcInfo SourceInfo
}

type
  SourceInfo = record
    FileName: Pointer;
    LineNumber: DWORD;
    ColumnNumber: DWORD;
    CharPosition: DWORD;
    Hash: Pointer;
  end;

  PropertyChainSource = record
    Handle: UInt64;
    TargetType: Pointer;
    Name: Pointer;
    Source: Integer;
    SrcInfo: SourceInfo;
  end;

const SourceInfo = extern struct {
    FileName: ?*anyopaque,
    LineNumber: u32,
    ColumnNumber: u32,
    CharPosition: u32,
    Hash: ?*anyopaque,
};

const PropertyChainSource = extern struct {
    Handle: u64,
    TargetType: ?*anyopaque,
    Name: ?*anyopaque,
    Source: i32,
    SrcInfo: SourceInfo,
};

type
  SourceInfo {.bycopy.} = object
    FileName: pointer
    LineNumber: uint32
    ColumnNumber: uint32
    CharPosition: uint32
    Hash: pointer

  PropertyChainSource {.bycopy.} = object
    Handle: uint64
    TargetType: pointer
    Name: pointer
    Source: int32
    SrcInfo: SourceInfo

struct SourceInfo
{
    void* FileName;
    uint LineNumber;
    uint ColumnNumber;
    uint CharPosition;
    void* Hash;
}

struct PropertyChainSource
{
    ulong Handle;
    void* TargetType;
    void* Name;
    int Source;
    SourceInfo SrcInfo;
}