#define NS_REQUIRES_SUPER   __attribute__((objc_requires_super))
#define NS_DESIGNATED_INITIALIZER __attribute__((objc_designated_initializer))
#define API_AVAILABLE(...)  __attribute__((availability(...)))

// Typical usage: register defaults / swizzle methods / initialize global state
__attribute__((constructor))
static void registerAnalyticsDefaults(void) {
    [[NSUserDefaults standardUserDefaults]
        registerDefaults:@{@"tracking_enabled": @YES}];
}

// You can even specify a priority for C++ static constructors
// (This is an LLVM-specific extension; GCC doesn't support constructor priorities for C++)
__attribute__((constructor(101)))
static void beforeAllCXXConstructors(void) {
    // Runs before C++ global objects are constructed
}

// Define a defer block type
typedef void (^cleanup_block_t)(void);

static inline void defer_block_cleanup(cleanup_block_t *block) {
    if (*block) (*block)();
}

// Core macro: use cleanup to guarantee the block runs at the end of scope
#define defer __strong cleanup_block_t __attribute__((cleanup(defer_block_cleanup))) __cleanup_block = ^

// Usage
- (void)doSomething {
    defer {
        NSLog(@"无论如何都会执行——类似 Go 的 defer");
        [self unlock];
    };

    [self lock];
    // Complex logic...
    if (someError) return; // 也会触发 defer
    // ...
}

__attribute__((objc_subclassing_restricted))
@interface AFHTTPSessionManager : NSObject
@end

// Equivalent to Swift's final class
// Compile-time check: any code that tries to inherit will error out
@interface MyManager : AFHTTPSessionManager  // ❌ Cannot subclass a class that was declared with objc_subclassing_restricted
@end

@interface MyView : UIView

- (instancetype)initWithFrame:(CGRect)frame
    __attribute__((objc_designated_initializer));  // 指定初始化器

- (instancetype)initWithFrame:(CGRect)frame style:(NSInteger)style
    __attribute__((objc_designated_initializer));  // 可以有多个

- (instancetype)initWithCoder:(NSCoder *)coder
    __attribute__((objc_designated_initializer));

@end

@implementation MyView

// Convenience initializers must call a designated initializer
- (instancetype)init {
    // If you don't call [self initWithFrame:], the compiler warns:
    // ⚠️ Convenience initializer missing a 'self' call to another initializer
    return [self initWithFrame:CGRectZero];
}

@end

@interface BaseViewController : UIViewController

- (void)viewDidLoad __attribute__((objc_requires_super));
- (void)setupNavigationBar __attribute__((objc_requires_super));

@end

@implementation MyViewController

- (void)viewDidLoad {
    // ⚠️ Method possibly missing a [super viewDidLoad] call
    [super viewDidLoad]; // 必须有这一行
}

@end

// Mark a single method as direct
- (int)fastFibonacci:(int)n __attribute__((objc_direct));

// Or mark an entire @implementation block
__attribute__((objc_direct_members))
@implementation MyClass {
    int _counter;
}

- (void)increment {
    _counter++;  // 直接访问 ivar，无 objc_msgSend 开销
}

- (int)value {
    return _counter;
}

@end

// Counter-examples: these don't work on direct methods
[obj performSelector:@selector(increment)];           // ❌ 运行时找不到
[self methodForSelector:@selector(increment)];        // ❌ 返回 NULL
[MyClass aspect_hookSelector:@selector(increment)];   // ❌ 无法 Hook

// Tells the compiler which method family this method belongs to (affects ARC behavior)
- (instancetype)initWithDictionary:(NSDictionary *)dict
    __attribute__((objc_method_family(init)));

// Available method families:
// init, alloc, new, copy, mutableCopy

// For example: make a method that doesn't start with init be recognized by ARC as init-family
- (MyObject *)createObject __attribute__((objc_method_family(init)));
// ARC applies retain/release logic to its return value, similar to init behavior

// Make a custom struct support the @(...) syntax
typedef struct __attribute__((objc_boxable)) {
    CGFloat width;
    CGFloat height;
} MySize;

MySize size = {100, 200};
NSValue *value = @(size);  // ✅ 合法

// System types like CGFloat, CGPoint, CGRect are all marked objc_boxable

__attribute__((objc_root_class))
@interface MyRootClass
@end

// Rarely used; usually only NSObject / NSProxy use this

// Compile-time name is MyClass, runtime name is _Internal_MyClass
__attribute__((objc_runtime_name("_Internal_MyClass")))
@interface MyClass : NSObject
@end

// The Swift compiler uses this heavily — to generate unique runtime names for @objc classes
// Regular developers basically never need it

// Tells ARC: this object is held externally, don't release it within this scope
UIView *view = _cachedView;
__attribute__((objc_externally_retained))
UIView *externalView = view;
// ARC won't insert a release afterwards

// Customize the function name in Swift
- (void)application:(UIApplication *)application
    didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
    __attribute__((swift_name("application(_:didFinishLaunchingWithOptions:)")));

// Method renaming (argument labels are renamed too)
- (void)handleURL:(NSURL *)url options:(NSDictionary *)options
    __attribute__((swift_name("handle(url:options:)")));

// Class renaming
__attribute__((swift_name("MyNewClassName")))
@interface OldObjCClassName : NSObject
@end

// Global variable / enum renaming
extern NSString * const kOldConstant
    __attribute__((swift_name("newConstantName")));

// Custom getter/setter
@property (nonatomic, readonly, getter=isEnabled) BOOL enabled
    __attribute__((swift_name("isFeatureEnabled")));

// The underlying implementation of NS_REFINED_FOR_SWIFT
__attribute__((swift_private))
- (void)internalSetup;

// Invisible in Swift; only ObjC can call it
// Use it with NS_REFINED_FOR_SWIFT for finer-grained API control

// Add attributes to the generated Swift interface
__attribute__((swift_attr("@available(*, deprecated, message: \"Use newAPI instead\")")))
- (void)oldAPI;

// CF-style manual memory management annotations (the underlying implementation)
- (id)newObject __attribute__((ns_returns_retained));
// The underlying implementation of NS_RETURNS_RETAINED

- (id)borrowedObject __attribute__((ns_returns_not_retained));
// Tells ARC the return value is a non-owning reference

// Corresponding macros: NS_RETURNS_RETAINED, NS_RETURNS_NOT_RETAINED
// And CF_RETURNS_RETAINED, CF_RETURNS_NOT_RETAINED (the CF versions)

// Tells ARC: the parameter is consumed by the callee; the caller doesn't need to release
- (void)takeOwnership:(id)obj __attribute__((ns_consumed));

// self is consumed (similar to the assignment in init's self = [super init])
- (instancetype)init __attribute__((ns_consumes_self));

// Prevents ARC from releasing early before you need it
- (void)usePointerToWeakObject {
    __weak id weakObj = self.obj;
    __attribute__((objc_precise_lifetime)) id strongObj = self.obj;
    // strongObj is guaranteed to stay alive for the entire scope and won't be released early via optimization

    // Without this attribute, ARC might release strongObj before it's used
    // But strongObj's retain is already here... the real scenario is using it together with cleanup
}

// A more practical scenario: combined with cleanup
__attribute__((objc_precise_lifetime))
__strong NSObject *precise __attribute__((cleanup(myCleanup))) = [NSObject new];
// Guarantees precise is still valid in the cleanup callback

{
    __strong NSObject *obj = [NSObject new];
} // 这里自动 release

// Since Swift 5, ignoring return values is forbidden by default; ObjC needs to mark it manually
- (instancetype)init __attribute__((warn_unused_result));
- (BOOL)trySomething __attribute__((warn_unused_result));

// In Swift:
//    func trySomething() -> Bool   — this kind of declaration inherently requires using the return value
// But an ObjC method with this attribute imported into Swift becomes:
//    the opposite of @discardableResult func trySomething() -> Bool
//    i.e. using the return value is mandatory

// Mark an old API as unavailable with a migration hint
- (void)oldMethod __attribute__((unavailable("请使用 newMethod 替代")));

// The underlying implementation of NS_UNAVAILABLE
+ (instancetype)new __attribute__((unavailable));

// Conditional unavailability (the underlying implementation of the newer availability macros)
- (void)iOSOnlyMethod
    __attribute__((availability(ios, introduced=14.0, deprecated=15.0)));

- (void)legacyAPI
    __attribute__((deprecated("在 v3.0 废弃，使用 modernAPI 替代")));

// For debugging, to keep the stack frames
__attribute__((disable_tail_calls))
- (void)recursiveMethod {
    // ...
    [self recursiveMethod];  // 不会被优化成跳转，保证栈回溯完整
}

// ⚠️ Note the difference between __attribute__((weak_import)) and __weak
// They're completely different things!

// weak_import: the symbol may not exist (checked at runtime)
extern int SomeFunction(void) __attribute__((weak_import));

if (SomeFunction != NULL) {
    SomeFunction();  // 如果符号不存在就不调用
}

// Classic scenario: use a new iOS API while remaining compatible with older versions
if (@available(iOS 15.0, *)) {
    // the symbol is guaranteed to exist
} else {
    // No compile error, but at runtime this symbol is NULL
}

// Tells the compiler this enum may have future values (switch will warn)
typedef NS_ENUM(NSInteger, ConnectionState) {
    ConnectionStateDisconnected,
    ConnectionStateConnecting,
    ConnectionStateConnected,
} __attribute__((enum_extensibility(open)));

// Effect: even if switch covers all cases, it still warns suggesting adding a default
// In Swift this corresponds to @frozen vs non-frozen enums

// An actual fragment from NSObject.h
__attribute__((objc_root_class))
@interface NSObject <NSObject> {
    Class isa  OBJC_ISA_AVAILABILITY;
}

// NSProxy.h
__attribute__((objc_root_class))
@interface NSProxy <NSObject> {
    Class isa;
}

// AFHTTPSessionManager.h
__attribute__((objc_subclassing_restricted))
@interface AFHTTPSessionManager : NSObject

// AFURLSessionManager.m
__attribute__((objc_direct_members))
@implementation AFURLSessionManager
// All internal methods use direct dispatch, for performance
@end

__attribute__((objc_subclassing_restricted))
@interface SDWebImageManager : NSObject

// Internally uses objc_direct extensively to reduce runtime overhead

// Many SDKs register themselves with constructor
__attribute__((constructor))
static void initializeAnalyticsSDK(void) {
    dispatch_async(dispatch_get_main_queue(), ^{
        [AnalyticsSDK startWithConfig:defaultConfig];
    });
}

// cleanup is exception-safe for ObjC/C++
// Even if an exception is thrown, cleanup variables in scope are still called

- (void)riskyOperation {
    __strong NSObject *obj __attribute__((cleanup(cleanupFunc))) = [NSObject new];

    @try {
        // ...
        @throw [NSException exceptionWithName:@"Error" reason:nil userInfo:nil];
    } @catch (NSException *e) {
        // cleanupFunc has already been called!
    }
}

// ❌ Wrong: used on a public API
- (void)publicMethod __attribute__((objc_direct));
// Categories can't override it, and KVO doesn't work

// ✅ Correct: internal private methods
- (void)_internalCalculation __attribute__((objc_direct));

// In Swift, just use final class — no attribute needed
final class MyManager { }

// In ObjC, if you also want to constrain Swift:
__attribute__((objc_subclassing_restricted))
@interface MyManager : NSObject
@end