类

class ClassTypeInfo

public class ClassTypeInfo <: TypeInfo {}

功能：描述 class 类型的类型信息。

父类型：

TypeInfo

prop constructors

public prop constructors: Collection<ConstructorInfo>

功能：获取该 ClassTypeInfo 对应的 class 的所有 public 构造函数信息，返回对应集合。

类型：Collection<ConstructorInfo>

示例：

package test

import std.reflect.*

public class Rectangular {
    public var myName = ""
    public init() {}
    public init(name: String) {
        myName = name
    }
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 ClassTypeInfo，也可以通过实例获取 ClassTypeInfo
    let ty = ClassTypeInfo.get("test.Rectangular")
    // 获取 constructors
    for (i in ty.constructors) {
        println(i)
    }
    return
}

运行结果：

init()
init(String)

prop instanceVariables

public prop instanceVariables: Collection<InstanceVariableInfo>

功能：获取该 ClassTypeInfo 对应的 class 的所有 public 实例成员变量信息，返回对应集合。

类型：Collection<InstanceVariableInfo>

示例：

package test

import std.reflect.*

public class Rectangular {
    public var length = 4
    public var width = 5
    public var myName = ""
    public init() {}
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 ClassTypeInfo，也可以通过实例获取 ClassTypeInfo
    let ty = ClassTypeInfo.get("test.Rectangular")
    // 获取 instanceVariables
    for (i in ty.instanceVariables) {
        println(i)
    }
    return
}

运行结果：

length: Int64
width: Int64
myName: String

prop sealedSubclasses

public prop sealedSubclasses: Collection<ClassTypeInfo>

功能：如果该 ClassTypeInfo 对应的 class 类型拥有 sealed 语义，则获取该 class 类型所在包内的所有子类的类型信息，返回对应集合。

类型：Collection<ClassTypeInfo>

示例：

package test

import std.reflect.*

sealed abstract class Shape {}

public class Circle <: Shape {}

public class Rectangle <: Shape {}

main(): Unit {
    // 获取 Shape 类型信息
    let ty = ClassTypeInfo.get("test.Shape")

    // 获取 sealed 子类
    for (subclass in ty.sealedSubclasses) {
        println(subclass)
    }

    return
}

运行结果：

test.Shape
test.Circle
test.Rectangle

prop staticVariables

public prop staticVariables: Collection<StaticVariableInfo>

功能：获取该 ClassTypeInfo 对应的 class 的所有 public 静态成员变量信息，返回对应集合。

类型：Collection<StaticVariableInfo>

示例：

package test

import std.reflect.*

public class Rectangular {
    public static var count: Int64 = 0
    public static var name: String = "Rectangle"
    public var length: Int64 = 0
    public var width: Int64 = 0

    public init() {
        Rectangular.count += 1
    }
}

main(): Unit {
    // 获取 Rectangular 类型信息
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 获取静态成员变量
    for (variable in ty.staticVariables) {
        println(variable)
    }

    return
}

运行结果：

static count: Int64
static name: String

prop superClass

public prop superClass: Option<ClassTypeInfo>

功能：获取该 class 类型信息所对应的 class 类型的直接父类。

类型：Option<ClassTypeInfo>

示例：

package test

import std.reflect.*

public open class Animal {
    public var name: String = ""
    public init() {}
}

public class Dog <: Animal {
    public init() {
        super()
    }
}

main(): Unit {
    // 获取 Dog 类型信息
    let ty = ClassTypeInfo.get("test.Dog")

    // 获取父类信息
    if (ty.superClass.isSome()) {
        // Dog 有父类
        println("Dog 有父类")
    } else {
        println("Dog 没有父类")
    }

    // 同时也获取 Object 类型信息作为对比
    let objTy = ClassTypeInfo.get("std.core.Object")
    if (objTy.superClass.isNone()) {
        println("Object 没有父类")
    }

    return
}

运行结果：

Dog 有父类
Object 没有父类

static func get(String)

public redef static func get(qualifiedName: String): ClassTypeInfo

功能：获取给定限定名称所对应类型的 ClassTypeInfo。

参数：

qualifiedName: String - 类型的限定名称。

返回值：

ClassTypeInfo - 类型的限定名称 qualifiedName 所对应的类型的类型信息。

异常：

InfoNotFoundException - 如果无法获取与给定类型的限定名称 qualifiedName 匹配的类型所对应的类型信息，则抛出异常。
IllegalTypeException - 如果获取到的类型信息不是 ClassTypeInfo，则抛出异常。

示例：

import std.reflect.*

public class Rectangular {}

main(): Unit {
    let ty = ClassTypeInfo.get("default.Rectangular")
    println(ty)
    return
}

运行结果：

default.Rectangular

static func of(Any)

public redef static func of(a: Any): ClassTypeInfo

功能：获取给定的任意类型的实例的运行时类型所对应的类型信息。

运行时类型是指在程序运行时，通过动态绑定确定的类型，运行时类型与实例对象相绑定。在继承等场景下运行时类型和静态类型可能不一致。

参数：

a: Any - 任意类型的实例。

返回值：

ClassTypeInfo - 实例 a 的运行时类型所对应的类型信息。

异常：

InfoNotFoundException - 如果无法获得实例 a 的运行时类型所对应的类型信息，则抛出异常。
IllegalTypeException - 如果获取到的类型信息不是 ClassTypeInfo，则抛出异常。

示例：

package test

import std.reflect.*

public class Rectangular {}

main(): Unit {
    var r = Rectangular()
    let ty = ClassTypeInfo.of(r)
    println(ty)
    return
}

运行结果：

test.Rectangular

static func of(Object)

public static func of(a: Object): ClassTypeInfo

功能：获取给定的 class 类型的实例的运行时类型所对应的 class 类型信息。

参数：

a: Object - class 类型的实例。

返回值：

ClassTypeInfo - class 类型的实例 a 的运行时类型所对应的 class 类型信息。

异常：

InfoNotFoundException - 如果无法获得实例 a 的运行时类型所对应的 class 类型信息，则抛出异常。

示例：

package test

import std.reflect.*

public class Rectangular {}

main(): Unit {
    var r = Rectangular()
    let ty = ClassTypeInfo.of(r)
    println(ty)
    return
}

运行结果：

test.Rectangular

static func of<T>()

public redef static func of<T>(): ClassTypeInfo

功能：获取给定类型 T 对应的类型信息。

返回值：

ClassTypeInfo - T 类型对应的类型信息。

异常：

InfoNotFoundException - 如果无法获得类型 T 所对应的类型信息，抛出异常。
IllegalTypeException - 如果获取到的类型信息不是 ClassTypeInfo，则抛出异常。

示例：

import std.reflect.*

public class Rectangular {}

main(): Unit {
    let ty = ClassTypeInfo.of<Rectangular>()
    println(ty)
    return
}

运行结果：

default.Rectangular

func construct(Array<Any>)

public func construct(args: Array<Any>): Any

功能：在该 ClassTypeInfo 对应的 class 类型中根据实参列表搜索匹配的构造函数并调用，传入实参列表，返回调用结果。

参数：

args: Array<Any> - 实参列表。

返回值：

Any - 该 class 类型的实例。

异常：

MisMatchException - 如果入参未能成功匹配任何该 class 类型的可见性为 public 的构造函数，则抛出异常。
InvocationTargetException - 在被调用的构造函数内部抛出的任何异常均将被封装为 InvocationTargetException 异常并抛出。

示例：

package test

import std.reflect.*

public class Rectangular {
    public var length = 4
    public var width = 5
    public var myName = ""
    public init() {}
    public init(name: String) {
        myName = name
    }
    public init(name: String, length: Int64, width: Int64) {
        myName = name
        this.length = length
        this.width = width
    }
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 ClassTypeInfo，也可以通过实例获取 ClassTypeInfo
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 通过不同入参构造实例
    ty.construct()
    ty.construct("Small rectangular")
    ty.construct("Big rectangular", 1, 1)
    return
}

func getConstructor(Array<TypeInfo>)

public func getConstructor(parameterTypes: Array<TypeInfo>): ConstructorInfo

功能：尝试在该 ClassTypeInfo 对应的 class 类型中获取与给定形参类型信息列表匹配的 public 构造函数的信息。

参数：

parameterTypes: Array<TypeInfo> - 形参类型信息列表。

返回值：

ConstructorInfo - 如果成功匹配则返回该 public 构造函数的信息。

异常：

InfoNotFoundException - 如果没找到对应 public 构造函数，则抛出异常。

示例：

package test

import std.reflect.*

public class Rectangular {
    public var length = 4
    public var width = 5
    public var myName = ""
    public init() {}
    public init(name: String) {
        myName = name
    }
    public init(name: String, length: Int64, width: Int64) {
        myName = name
        this.length = length
        this.width = width
    }
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 ClassTypeInfo，也可以通过实例获取 ClassTypeInfo
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 获取指定构造函数信息
    let ci01 = ty.getConstructor(StructTypeInfo.get("String"))
    println(ci01)

    // 获取指定构造函数信息
    let ci02 = ty.getConstructor(StructTypeInfo.get("String"), PrimitiveTypeInfo.get("Int64"),
        PrimitiveTypeInfo.get("Int64"))
    println(ci02)
    return
}

运行结果：

init(String)
init(String, Int64, Int64)

func getInstanceVariable(String)

public func getInstanceVariable(name: String): InstanceVariableInfo

功能：给定变量名称，尝试获取该 ClassTypeInfo 所对应的 class 类型中匹配的实例成员变量的信息。

参数：

name: String - 变量名称。

返回值：

InstanceVariableInfo - 如果成功匹配则返回该实例成员变量的信息。

异常：

InfoNotFoundException - 如果没找到对应实例成员变量，则抛出异常。

示例：

package test

import std.reflect.*

public class Rectangular {
    public var length = 4
    public var width = 5
    public var myName = ""
    public init() {}
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 ClassTypeInfo，也可以通过实例获取 ClassTypeInfo
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 获取类实例成员信息
    let ivi = ty.getInstanceVariable("myName")
    println(ivi)
    return
}

运行结果：

myName: String

func getStaticVariable(String)

public func getStaticVariable(name: String): StaticVariableInfo

功能：给定变量名称，尝试获取该 ClassTypeInfo 所对应的 class 类型中匹配的静态成员变量的信息。

参数：

name: String - 变量名称。

返回值：

StaticVariableInfo - 如果成功匹配则返回该静态成员变量的信息。

异常：

InfoNotFoundException - 如果没找到对应静态成员变量，则抛出异常。

示例：

package test

import std.reflect.*

public class Rectangular {
    public static var area: Int64 = 10
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 ClassTypeInfo，也可以通过实例获取 ClassTypeInfo
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 获取静态变量
    let sv = ty.getStaticVariable("area")
    println(sv)
    return
}

运行结果：

static area: Int64

func isAbstract()

public func isAbstract(): Bool

功能：判断该 ClassTypeInfo 对应的 class 类型是否是抽象类。

返回值：

Bool - 如果该 ClassTypeInfo 对应的 class 类型是抽象类则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public abstract class Shape {
    public init() {}
}

public class Circle <: Shape {
    public init() {
        super()
    }
}

main(): Unit {
    // 获取 Shape 类型信息
    let shapeTy = ClassTypeInfo.get("test.Shape")
    println("Shape 是抽象类: ${shapeTy.isAbstract()}")

    // 获取 Circle 类型信息
    let circleTy = ClassTypeInfo.get("test.Circle")
    println("Circle 是抽象类: ${circleTy.isAbstract()}")

    return
}

运行结果：

Shape 是抽象类: true
Circle 是抽象类: false

func isOpen()

public func isOpen(): Bool

功能：判断该 ClassTypeInfo 对应的 class 类型是否拥有 open 语义。

返回值：

Bool - 如果该 ClassTypeInfo 对应的 class 类型拥有 open 语义则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public open class OpenClass {
    public init() {}
}

public class RegularClass {
    public init() {}
}

main(): Unit {
    // 获取 OpenClass 类型信息
    let openTy = ClassTypeInfo.get("test.OpenClass")
    println("OpenClass 拥有 open 语义: ${openTy.isOpen()}")

    // 获取 RegularClass 类型信息
    let regularTy = ClassTypeInfo.get("test.RegularClass")
    println("RegularClass 拥有 open 语义: ${regularTy.isOpen()}")

    return
}

运行结果：

OpenClass 拥有 open 语义: true
RegularClass 拥有 open 语义: false

func isSealed()

public func isSealed(): Bool

功能：判断该 ClassTypeInfo 对应的 class 类型是否拥有 sealed 语义。

返回值：

Bool - 如果该 ClassTypeInfo 对应的 class 类型拥有 sealed 语义则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

sealed abstract class SealedClass {
    public init() {}
}

public class RegularClass {
    public init() {}
}

main(): Unit {
    // 获取 SealedClass 类型信息
    let sealedTy = ClassTypeInfo.get("test.SealedClass")
    println("SealedClass 拥有 sealed 语义: ${sealedTy.isSealed()}")

    // 获取 RegularClass 类型信息
    let regularTy = ClassTypeInfo.get("test.RegularClass")
    println("RegularClass 拥有 sealed 语义: ${regularTy.isSealed()}")

    return
}

运行结果：

SealedClass 拥有 sealed 语义: true
RegularClass 拥有 sealed 语义: false

class ConstructorInfo

public class ConstructorInfo <: Equatable<ConstructorInfo> & Hashable & ToString {}

功能：描述构造函数信息。

父类型：

prop annotations

public prop annotations: Collection<Annotation>

功能：获取所有作用于该 ConstructorInfo 对应的构造函数的自定义注解，返回对应集合。

类型：Collection<Annotation>

示例：

package test

import std.reflect.*

@Annotation
public class MyAnnotation {
    public let data: String
    public const init() {
        this.data = "MyAnnotation's data"
    }
}

@MyAnnotation
public class Rectangular {
    public var length = 4
    public var width = 5
    public var myName = ""

    @MyAnnotation
    public init() {}

    @MyAnnotation
    public init(name: String) {
        myName = name
    }
}

main(): Unit {
    // 获取 Rectangular 类型信息
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 遍历所有构造函数
    for (constructor in ty.constructors) {
        // 获取构造函数上的注解
        let annotations = constructor.annotations
        for (annotation in annotations) {
            let myAnnotation = (annotation as MyAnnotation).getOrThrow()
            println("构造函数 ${constructor} 上的注解数据: ${myAnnotation.data}")
        }
    }
    return
}

运行结果：

构造函数 init() 上的注解数据: MyAnnotation's data
构造函数 init(String) 上的注解数据: MyAnnotation's data

prop parameters

public prop parameters: ReadOnlyList<ParameterInfo>

功能：获取该 ConstructorInfo 所对应的构造函数的参数类型列表。

类型：ReadOnlyList<ParameterInfo>

示例：

package test

import std.reflect.*

public class Rectangular {
    public var length = 4
    public var width = 5
    public var myName = ""
    public init() {}
    public init(name: String) {
        myName = name
    }
    public init(name: String, length: Int64, width: Int64) {
        myName = name
        this.length = length
        this.width = width
    }
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 ClassTypeInfo，也可以通过实例获取 ClassTypeInfo
    let ty = ClassTypeInfo.get("test.Rectangular")
    // 获取 constructors
    for (i in ty.constructors) {
        // 获取 parameters
        for (j in i.parameters) {
            println("${i} 的入参有 ${j}")
        }
    }
    return
}

运行结果：

init(String) 的入参有 String
init(String, Int64, Int64) 的入参有 String
init(String, Int64, Int64) 的入参有 Int64
init(String, Int64, Int64) 的入参有 Int64

func apply(Array<Any>)

public func apply(args: Array<Any>): Any

功能：调用该 ConstructorInfo 对应的构造函数，传入实参列表，并返回调用结果。

参数：

args: Array<Any> - 实参列表。

返回值：

Any - 由该构造函数构造得到的类型实例。

异常：

InvocationTargetException - 如果该构造函数信息所对应的构造函数所属的类型是抽象类，则会抛出异常。
IllegalArgumentException - 如果实参列表中的实参的数目与该构造函数信息所对应的构造函数的形参列表中的形参的数目不等，则抛出异常。
IllegalTypeException - 如果实参列表中的任何一个实参的运行时类型不是该构造函数信息所对应的构造函数的对应形参的声明类型的子类型，则抛出异常。
Exception - 如果被调用的构造函数信息所对应的构造函数内部抛出异常，则该异常将被封装为 Exception 异常并抛出。

示例：

package test

import std.reflect.*

public class Rectangular {
    public var length = 4
    public var width = 5
    public var myName = ""

    public init() {
        println("调用了无参构造函数")
    }

    public init(name: String) {
        println("调用了有参构造函数")
        myName = name
    }
}

main(): Unit {
    // 获取 Rectangular 类型信息
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 遍历构造函数
    for (constructor in ty.constructors) {
        // 找到无参构造函数
        if (constructor.parameters.size == 0) {
            // 创建空参数数组
            let args: Array<Any> = []

            // 调用构造函数
            let instance = constructor.apply(args)
            // 将实例转换为 Rectangular 类型
            let rect = (instance as Rectangular).getOrThrow()
            println("无参构造实例的长度是: ${rect.length}, 宽度是: ${rect.width}, 名称是: ${rect.myName}")
        }
        // 找到有参构造函数
        if (constructor.parameters.size == 1) {
            // 创建有参数数组
            let args: Array<Any> = ["MyRectangular"]

            // 调用构造函数
            let instance = constructor.apply(args)
            // 将实例转换为 Rectangular 类型
            let rect = (instance as Rectangular).getOrThrow()
            println("有参构造实例的长度是: ${rect.length}, 宽度是: ${rect.width}, 名称是: ${rect.myName}")
        }
    }

    return
}

运行结果：

调用了无参构造函数
无参构造实例的长度是: 4, 宽度是: 5, 名称是: 
调用了有参构造函数
有参构造实例的长度是: 4, 宽度是: 5, 名称是: MyRectangular

func findAllAnnotations<T>() where T <: Annotation

public func findAllAnnotations<T>(): Array<T> where T <: Annotation

功能：获取所有指定注解名称的自定义注解（通过泛型筛选）。

返回值：

Array<T> - 若无指定 T 类型的注解时，返回空数组；若有相关注解时，将所有该类型注解对象构成的数组返回。

示例：

package test

import std.reflect.*

@Annotation
public class MyAnnotation01 {
    public let data: String
    public const init() {
        this.data = "MyAnnotation01's data"
    }
}

@Annotation
public class MyAnnotation02 {
    public let data: String
    public const init() {
        this.data = "MyAnnotation02's data"
    }
}

public class Rectangular {
    public var length = 4
    public var width = 5
    public var myName = ""

    @MyAnnotation01
    @MyAnnotation02
    public init() {}

    @MyAnnotation01
    @MyAnnotation01
    @MyAnnotation02
    public init(name: String) {
        myName = name
    }
}

main(): Unit {
    // 获取 Rectangular 类型信息
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 遍历所有构造函数
    for (constructor in ty.constructors) {
        // 获取构造函数上所有 MyAnnotation01 注解
        let annotations = constructor.findAllAnnotations<MyAnnotation01>()
        for (myAnnotation in annotations) {
            println("构造函数 ${constructor} 上的注解数据: ${myAnnotation.data}")
        }
    }
    return
}

运行结果：

构造函数 init() 上的注解数据: MyAnnotation01's data
构造函数 init(String) 上的注解数据: MyAnnotation01's data
构造函数 init(String) 上的注解数据: MyAnnotation01's data

func findAnnotation<T>() where T <: Annotation

public func findAnnotation<T>(): ?T where T <: Annotation

功能：尝试获取指定注解名称的自定义注解（通过泛型筛选）。

返回值：

?T - 如果成功匹配则返回该注解，重复标注或者无法匹配时返回 None。

示例：

package test

import std.reflect.*

@Annotation
public class MyAnnotation01 {
    public let data: String
    public const init() {
        this.data = "MyAnnotation01's data"
    }
}

@Annotation
public class MyAnnotation02 {
    public let data: String
    public const init() {
        this.data = "MyAnnotation02's data"
    }
}

public class Rectangular {
    public var length = 4
    public var width = 5
    public var myName = ""

    @MyAnnotation01
    @MyAnnotation02
    public init() {}

    @MyAnnotation01
    public init(name: String) {
        myName = name
    }
}

main(): Unit {
    // 获取 Rectangular 类型信息
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 遍历所有构造函数
    for (constructor in ty.constructors) {
        // 尝试获取构造函数上 MyAnnotation01 注解
        let annotation = constructor.findAnnotation<MyAnnotation01>().getOrThrow()
        println("构造函数 ${constructor} 上的注解数据: ${annotation.data}")
    }
    return
}

运行结果：

构造函数 init() 上的注解数据: MyAnnotation01's data
构造函数 init(String) 上的注解数据: MyAnnotation01's data

func getAllAnnotations()

public func getAllAnnotations(): Array<Annotation>

功能：获取作用于该构造函数的所有自定义注解。

返回值：

Array<Annotation> - 作用于该对象的所有注解。

示例：

package test

import std.reflect.*

@Annotation
public class MyAnnotation01 {
    public let data: String
    public const init() {
        this.data = "MyAnnotation01's data"
    }
}

@Annotation
public class MyAnnotation02 {
    public let data: String
    public const init() {
        this.data = "MyAnnotation02's data"
    }
}

public class Rectangular {
    public var length = 4
    public var width = 5
    public var myName = ""

    @MyAnnotation01
    @MyAnnotation02
    public init() {}

    @MyAnnotation01
    @MyAnnotation02
    public init(name: String) {
        myName = name
    }
}

main(): Unit {
    // 获取 Rectangular 类型信息
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 遍历所有构造函数
    for (constructor in ty.constructors) {
        // 尝试获取构造函数上所有注解
        let annotations = constructor.getAllAnnotations()
        for (annotation in annotations) {
            if (annotation is MyAnnotation01) {
                let myAnnotation = (annotation as MyAnnotation01).getOrThrow()
                println("构造函数 ${constructor} 上的注解数据: ${myAnnotation.data}")
            } else if (annotation is MyAnnotation02) {
                let myAnnotation = (annotation as MyAnnotation02).getOrThrow()
                println("构造函数 ${constructor} 上的注解数据: ${myAnnotation.data}")
            }
        }
    }
    return
}

运行结果：

构造函数 init() 上的注解数据: MyAnnotation01's data
构造函数 init() 上的注解数据: MyAnnotation02's data
构造函数 init(String) 上的注解数据: MyAnnotation01's data
构造函数 init(String) 上的注解数据: MyAnnotation02's data

func hashCode()

public func hashCode(): Int64

功能：获取该构造器信息的哈希值。

返回值：

Int64 - 该构造器信息的哈希值。

示例：

package test

import std.reflect.*

public class Rectangular {
    public var length = 4
    public var width = 5
    public var myName = ""

    public init() {}

    public init(name: String) {
        myName = name
    }
}

main(): Unit {
    // 获取 Rectangular 类型信息
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 遍历所有构造函数并获取哈希值
    for (constructor in ty.constructors) {
        let hash = constructor.hashCode()
        println("构造函数 ${constructor} 的哈希值: ${hash}")
    }

    return
}

可能的运行结果：

构造函数 init() 的哈希值: 93932258392112
构造函数 init(String) 的哈希值: 93932258392208

func toString()

public func toString(): String

功能：获取字符串形式的该构造函数信息。

返回值：

String - 字符串形式的该构造函数信息。

示例：

package test

import std.reflect.*

public class Rectangular {
    public var length = 4
    public var width = 5
    public var myName = ""

    public init() {}

    public init(name: String) {
        myName = name
    }
}

main(): Unit {
    // 获取 Rectangular 类型信息
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 遍历所有构造函数并获取字符串表示
    for (constructor in ty.constructors) {
        let str = constructor.toString()
        println("构造函数的字符串表示: ${str}")
    }

    return
}

运行结果：

构造函数的字符串表示: init()
构造函数的字符串表示: init(String)

operator func !=(ConstructorInfo)

public operator func !=(other: ConstructorInfo): Bool

功能：判断该构造器信息与给定的另一个构造器信息是否不等。

参数：

other: ConstructorInfo - 被比较相等性的另一个构造器信息。

返回值：

Bool - 如果该构造器信息与另一个不等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public class Rectangular {
    public var length = 4
    public var width = 5
    public var myName = ""

    public init() {}

    public init(name: String) {
        myName = name
    }
}

main(): Unit {
    // 获取 Rectangular 类型信息
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 获取所有构造函数
    let constructors = ty.constructors.toArray()

    // 收集两个构造函数
    let firstConstructor: ConstructorInfo = constructors[0]
    let secondConstructor: ConstructorInfo = constructors[1]

    // 比较不同的构造函数
    let result = firstConstructor != secondConstructor
    println("两个不同构造函数不等: ${result}")

    // 比较相同的构造函数
    let firstConstructor1: ConstructorInfo = ClassTypeInfo.get("test.Rectangular").constructors.toArray()[0]
    let result2 = firstConstructor != firstConstructor1
    println("相同构造函数不等: ${result2}")

    return
}

运行结果：

两个不同构造函数不等: true
相同构造函数不等: false

operator func ==(ConstructorInfo)

public operator func ==(other: ConstructorInfo): Bool

功能：判断该构造器信息与给定的另一个构造器信息是否相等。

参数：

other: ConstructorInfo - 被比较相等性的另一个构造器信息。

返回值：

Bool - 如果该构造器信息与另一个相等则返回 true，否则返回 false。

class EnumConstructorInfo

public class EnumConstructorInfo <: Equatable<EnumConstructorInfo> & Hashable & ToString

功能：描述枚举构造子信息，可用于查询构造子参数类型、注解，并根据构造子进行构造/拆解枚举实例。

父类型：

prop annotations

public prop annotations: Collection<Annotation>

功能：获取所有作用于该枚举构造子上的注解集合。

类型：Collection<Annotation>

示例：

package test

import std.reflect.*

public enum E {
    | M1
}

main(): Unit {
    let ctor = EnumTypeInfo.get("test.E").getConstructor("M1")
    let annos = ctor.annotations.toArray()
    println(annos.size)
    return
}

运行结果：

prop enumTypeInfo

public prop enumTypeInfo: EnumTypeInfo

功能：获取该枚举构造子所属枚举类型的 EnumTypeInfo。

类型：EnumTypeInfo

异常：

MisMatchException - 如果声明类型不是枚举类型，则抛出异常。

示例：

package test

import std.reflect.*

public enum E {
    | M1
}

main(): Unit {
    let ctor = EnumTypeInfo.get("test.E").getConstructor("M1")
    println(ctor.enumTypeInfo.qualifiedName)
    return
}

运行结果：

test.E

prop name

public prop name: String

功能：获取该枚举构造子的名称（不包含包名前缀）。

类型：String

示例：

package test

import std.reflect.*

public enum E {
    | M2(Int64)
}

main(): Unit {
    let ctor = EnumTypeInfo.get("test.E").getConstructor("M2", argsCount: 1)
    println(ctor.name)
    return
}

运行结果：

M2

prop qualifiedName

public prop qualifiedName: String

功能：获取该枚举构造子的限定名称。

类型：String

示例：

package test

import std.reflect.*

public enum E {
    | M2(Int64)
}

main(): Unit {
    let ctor = EnumTypeInfo.get("test.E").getConstructor("M2", argsCount: 1)
    println(ctor.qualifiedName)
    return
}

运行结果：

test.E.M2<Int64>

prop parameters

public prop parameters: ReadOnlyList<TypeInfo>

功能：获取该枚举构造子的参数类型列表，按声明顺序返回。

类型：ReadOnlyList<TypeInfo>

示例：

package test

import std.reflect.*

public enum E {
    | M3(Int64, String)
}

main(): Unit {
    let ctor = EnumTypeInfo.get("test.E").getConstructor("M3", argsCount: 2)
    let params = ctor.parameters
    println(params.size)
    println(params[0].name)
    println(params[1].name)
    return
}

运行结果：

2
Int64
String

static func get(String)

public static func get(qualifiedName: String): EnumConstructorInfo

功能：获取给定限定名称所对应的 EnumConstructorInfo。

参数：

qualifiedName: String - 枚举构造子的限定名称，例如 default.E.M2<Int64>。

返回值：

EnumConstructorInfo - 与 qualifiedName 对应的枚举构造子信息。

异常：

IllegalTypeException - 如果 qualifiedName 对应的类型不是枚举类型或不存在，则抛出异常。

示例：

package test

import std.reflect.*

public enum E {
    | M2(Int64)
}

main(): Unit {
    let ctor = EnumConstructorInfo.get("test.E.M2<Int64>")
    println(ctor.qualifiedName)
    return
}

运行结果：

test.E.M2<Int64>

static func of(Any)

public static func of(instance: Any): EnumConstructorInfo

功能：获取给定枚举实例所属的构造子信息。

参数：

instance: Any - 枚举实例。

返回值：

EnumConstructorInfo - instance 所属构造子信息。

异常：

IllegalTypeException - 如果 instance 不是该枚举的实例，则抛出异常。

示例：

package test

import std.reflect.*

public enum E {
    | M1
    | M2(Int64)
    | M3(Int64, String)
}

main(): Unit {
    let inst = E.M3(7, "hi")
    let ctor = EnumConstructorInfo.of(inst)
    println(ctor.qualifiedName)
    let values = ctor.getAssociatedValues(inst)
    println(values.size)
    println(values[0] as Int64)
    println(values[1] as String)
    return
}

运行结果：

test.E.M3<Int64, String>
2
Some(7)
Some(hi)

func apply(Array<Any>)

public func apply(args: Array<Any>): Any

功能：根据传入的参数列表，构造相应的枚举实例。

参数：

args: Array<Any> - 构造子参数的实参列表，顺序需与构造子声明一致。

返回值：

Any - 由该构造子创建的枚举实例。

异常：

InvocationTargetException - 当实参个数与构造子参数个数不一致，或任一实参的运行时类型与对应形参类型不匹配时抛出。

示例：

package test

import std.reflect.*

public enum E <: ToString {
    M1 | M2(Int64)

    public func toString(): String {
        match (this) {
            case M1 => "M1"
            case M2(val) => "M2(${val})"
        }
    }
}

main(): Unit {
    let ctor = EnumTypeInfo.get("test.E").getConstructor("M2", argsCount: 1)
    let inst = (ctor.apply([7]) as E).getOrThrow()
    println(inst)
    return
}

运行结果：

M2(7)

func getAssociatedValues(Any)

public func getAssociatedValues(instance: Any): ReadOnlyList<Any>

功能：获取给定枚举实例的关联值列表。

参数：

instance: Any - 枚举实例。

返回值：

ReadOnlyList<Any> - 关联值列表，按声明顺序返回。

异常：

IllegalTypeException - 如果 instance 不是通过该构造子与创建的，则抛出异常。

示例：

package test

import std.reflect.*

public enum E {
    | M2(Int64)
}

main(): Unit {
    let ctor = EnumTypeInfo.get("test.E").getConstructor("M2", argsCount: 1)
    let values = ctor.getAssociatedValues(E.M2(7))
    println(values.size)
    println(values[0] as Int64)
    return
}

运行结果：

1
Some(7)

func findAllAnnotations<T>()

public func findAllAnnotations<T>(): Array<T> where T <: Annotation

功能：获取该构造子上的所有类型为 T 的注解实例。

返回值：

Array<T> - 注解列表。

示例：

package test

import std.reflect.*

@Annotation
public class A1 {
    public const init() {}
}

public enum E {
    | M1
}

main(): Unit {
    let ctor = EnumTypeInfo.get("test.E").getConstructor("M1")
    let annos = ctor.findAllAnnotations<A1>()
    println(annos.size)
    return
}

运行结果：

func findAllAnnotation<T>()

public func findAllAnnotation<T>(): ?T where T <: Annotation

功能：获取该构造子上的任意一个类型为 T 的注解实例。

返回值：

?T - 注解实例或 None。

示例：

package test

import std.reflect.*

@Annotation
public class A1 {
    public const init() {}
}

public enum E {
    | M1
}

main(): Unit {
    let ctor = EnumTypeInfo.get("test.E").getConstructor("M1")
    println(ctor.findAllAnnotation<A1>().isNone())
    return
}

运行结果：

true

func getAllAnnotations()

public func getAllAnnotations(): Array<Annotation>

功能：获取该构造子上的所有注解实例数组。

返回值：

Array<Annotation> - 注解数组。

示例：

package test

import std.reflect.*

public enum E {
    | M1
}

main(): Unit {
    let ctor = EnumTypeInfo.get("test.E").getConstructor("M1")
    println(ctor.getAllAnnotations().size)
    return
}

运行结果：

func hashCode()

public func hashCode(): Int64

功能：获取该构造子信息的哈希值。

返回值：

Int64 - 哈希值。

示例：

package test

import std.reflect.*

public enum E {
    | M1
}

main(): Unit {
    let ctor = EnumTypeInfo.get("test.E").getConstructor("M1")
    println(ctor.hashCode() == ctor.hashCode())
    return
}

运行结果：

true

operator func ==(EnumConstructorInfo)

public operator func ==(other: EnumConstructorInfo): Bool

功能：判断该构造子信息与另一个构造子信息是否相等。

参数：

other: EnumConstructorInfo - 另一个构造子信息。

返回值：

Bool - 相等返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public enum E {
    | M1
    | M2(Int64)
}

main(): Unit {
    let e = EnumTypeInfo.get("test.E")
    let c1 = e.getConstructor("M1")
    let c2 = e.getConstructor("M2", argsCount: 1)
    println(c1 == c1)
    println(c1 == c2)
    return
}

运行结果：

true
false

func toString()

public func toString(): String

功能：获取该构造子信息的字符串表示，等价于 qualifiedName。

返回值：

String - 字符串表示。

示例：

package test

import std.reflect.*

public enum E {
    | M1
}

main(): Unit {
    let ctor = EnumTypeInfo.get("test.E").getConstructor("M1")
    println(ctor.toString())
    return
}

运行结果：

test.E.M1

class EnumTypeInfo

public class EnumTypeInfo <: TypeInfo

功能：Enum 类型的类型信息。

父类型：

TypeInfo

prop constructors

public prop constructors: Collection<EnumConstructorInfo>

功能：获取该 EnumTypeInfo 对应的所有枚举构造子信息，返回对应集合。

类型：Collection<EnumConstructorInfo>

示例：

package test

import std.reflect.*

public enum E {
    | M1
    | M2(Int64)
}

main(): Unit {
    let e = EnumTypeInfo.get("test.E")
    let ctors = e.constructors.toArray()
    println(ctors.size)
    return
}

运行结果：

static func get(String)

public redef static func get(qualifiedName: String): EnumTypeInfo

功能：获取给定限定名称所对应类型的 EnumTypeInfo。

参数：

qualifiedName: String - 类型的限定名称。

返回值：

EnumTypeInfo - 与 qualifiedName 对应的枚举类型信息。

异常：

IllegalTypeException - 如果获取到的类型信息不是枚举类型或者 qaulifiedName 对应的定义不存在，则抛出异常。

示例：

package test

import std.reflect.*

public enum E {
    | M1
    | M2(Int64)
}

main(): Unit {
    let e1 = EnumTypeInfo.get("test.E")
    println(e1.qualifiedName)
    return
}

运行结果：

test.E

static func of(Any)

public static redef func of(instance: Any): EnumTypeInfo

功能：获取给定实例所属枚举类型的 EnumTypeInfo。

参数：

instance: Any - 枚举实例。

返回值：

EnumTypeInfo - instance 所属枚举类型的类型信息。

异常：

IllegalTypeException - 如果 instance 不是枚举类型，则抛出异常。

示例：

package test

import std.reflect.*

public enum E {
    | M1
}

main(): Unit {
    let info = EnumTypeInfo.of(E.M1)
    println(info.qualifiedName)
    return
}

运行结果：

test.E

static func of<T>()

public static redef func of<T>(): EnumTypeInfo

功能：获取给定类型 T 所属枚举类型的 EnumTypeInfo。

返回值：

EnumTypeInfo - T 所属枚举类型的类型信息。

异常：

IllegalTypeException - 如果 T 不是任何枚举类型，则抛出异常。

示例：

package test

import std.reflect.*

public enum E {
    | M1
}

main(): Unit {
    let info = EnumTypeInfo.of<E>()
    println(info.name)
    return
}

运行结果：

func construct(String, Array<Any>)

public func construct(constructor: String, args: Array<Any>): Any

功能：根据构造子签名和实参列表构造该枚举的实例并返回。

参数：

constructor: String - 构造子签名。
args: Array<Any> - 构造子实参列表。

返回值：

Any - 构造出的枚举实例。

异常：

InvocationTargetException - 如果 args 的数量或类型与构造子参数不匹配或者指定的构造子不存在，则抛出异常。

示例：

package test

import std.reflect.*

public enum E {
    | M1
    | M3(Int64, String)
}

main(): Unit {
    let e = EnumTypeInfo.get("test.E")
    let inst = (e.construct("M3<Int64, String>", [42, "abc"]) as E).getOrThrow()
    match (inst) {
        case E.M3(v1, v2) => println("${v1}, ${v2}")
        case _ => println("unexpected")
    }
    return
}

运行结果：

42, abc

func destruct(Any)

public func destruct(instance: Any): (EnumConstructorInfo, ReadOnlyList<Any>)

功能：拆解给定枚举实例，返回其构造子信息和关联值列表。

参数：

instance: Any - 枚举实例。

返回值：

(EnumConstructorInfo, ReadOnlyList<Any>) - 构造子信息与关联值列表。

异常：

IllegalTypeException - 如果 instance 不是枚举类型实例，则抛出异常。

示例：

package test

import std.reflect.*

public enum E {
    | M1
    | M2(Int64)
}

main(): Unit {
    let e = EnumTypeInfo.get("test.E")
    let (ctor, values) = e.destruct(E.M2(7))
    println(ctor.qualifiedName)
    println(values.size)
    println(values[0] as Int64)
    return
}

运行结果：

test.E.M2<Int64>
1
Some(7)

func getConstructor(String, Int64)

public func getConstructor(constructor: String, argsCount!: Int64 = 0): EnumConstructorInfo

功能：按构造子名与参数个数查询构造子信息。

参数：

constructor: String - 构造子名（不含参数签名），例如 M2。
argsCount!: Int64 - 参数个数；为 0 时不限制参数个数。

返回值：

EnumConstructorInfo - 匹配到的构造子信息。

异常：

InfoNotFoundException - 如果未找到匹配的构造子，则抛出异常。

示例：

package test

import std.reflect.*

public enum E {
    | M1
    | M2(Int64)
    | M2(Int64, Int64)
}

main(): Unit {
    let e = EnumTypeInfo.get("test.E")
    println(e.getConstructor("M1").qualifiedName)
    println(e.getConstructor("M2", argsCount: 1).qualifiedName)
    println(e.getConstructor("M2", argsCount: 2).qualifiedName)
    return
}

运行结果：

test.E.M1
test.E.M2<Int64>
test.E.M2<Int64, Int64>

class FunctionTypeInfo

public class FunctionTypeInfo <: TypeInfo

功能：描述函数类型（函数值/闭包）的类型信息，可用于获取参数与返回值的类型信息。

父类型：

TypeInfo

prop parameters

public prop parameters: ReadOnlyList<TypeInfo>

功能：获取该函数类型的参数类型列表，按声明顺序返回。

类型：ReadOnlyList<TypeInfo>

示例：

package test

import std.reflect.*

main(): Unit {
    let f = { x: Int64, y: UInt8 => x + Int64(y) }
    let info = FunctionTypeInfo.of(f)
    println(info.parameters.size)
    println(info.parameters[0].name)
    println(info.parameters[1].name)
    return
}

运行结果：

2
Int64
UInt8

prop returnType

public prop returnType: TypeInfo

功能：获取该函数类型的返回值类型信息。

类型：TypeInfo

示例：

package test

import std.reflect.*

main(): Unit {
    let f = { x: Int64, y: Int64 => x + y }
    let info = FunctionTypeInfo.of(f)
    println(info.returnType.name)
    return
}

运行结果：

Int64

static func of(Any)

public redef static func of(instance: Any): FunctionTypeInfo

功能：获取给定实例的运行时类型所对应的 FunctionTypeInfo。

运行时类型是指在程序运行时，通过动态绑定确定的类型，运行时类型与实例对象相绑定。在继承等场景下运行时类型和静态类型可能不一致。

参数：

instance: Any - 运行时类型为函数类型的实例。

返回值：

FunctionTypeInfo - 实例 instance 的运行时类型所对应的类型信息。

异常：

IllegalTypeException - 如果获取到的类型信息不是函数类型，则抛出异常。

示例：

package test

import std.reflect.*

func add(a: Int64, b: Int64): Int64 {
    a + b
}

main(): Unit {
    let f: (Int64, Int64) -> Int64 = add
    let info = FunctionTypeInfo.of(f)
    println(info.parameters.size)
    println(info.returnType.name)
    return
}

运行结果：

2
Int64

static func of<T>()

public static redef func of<T>(): FunctionTypeInfo

功能：获取给定类型 T 对应的 FunctionTypeInfo。

返回值：

FunctionTypeInfo - T 类型对应的函数类型信息。

异常：

IllegalTypeException - 如果获取到的类型信息不是函数类型，则抛出异常。

示例：

package test

import std.reflect.*

main(): Unit {
    let info = FunctionTypeInfo.of<(Int64, String) -> Bool>()
    println(info.parameters.size)
    println(info.parameters[1].name)
    println(info.returnType.name)
    return
}

运行结果：

2
String
Bool

func apply(Any, Array<Any>)

public func apply(instance: Any, args: Array<Any>): Any

功能：按函数参数顺序传入实参列表，对函数进行调用并返回调用结果。

参数：

instance: Any - 函数实例。
args: Array<Any> - 实参列表。

返回值：

Any - 调用结果。

异常：

IllegalArgumentException - 如果 args 的数量与函数参数个数不一致，则抛出异常。
IllegalTypeException - 如果 args 中任一元素类型与对应元组元素类型不匹配，则抛出异常。

示例：

package test

import std.reflect.*

func add(a: Int64, b: Int64): Int64 {
    a + b
}

main(): Unit {
    let f: (Int64, Int64) -> Int64 = add
    let info = FunctionTypeInfo.of(f)
    let res = (info.apply(f, [1, 2]) as Int64).getOrThrow()
    println(res)
    return
}

运行结果：

class GenericTypeInfo

public class GenericTypeInfo <: TypeInfo & Equatable<GenericTypeInfo> {}

功能：描述泛型类型信息。

父类型：

operator func ==(GenericTypeInfo)

public operator func ==(other: GenericTypeInfo): Bool

功能：判断该泛型类型信息与给定的另一个泛型类型信息是否相等。

参数：

other: GenericTypeInfo - 被比较相等性的另一个泛型类型信息。

返回值：

Bool - 如果该泛型类型信息与另一个相等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public func myFunc<T>(str: String, toStr: T): Unit where T <: ToString {
    println("${str}: ${toStr}")
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的第一个全局函数信息
    let globalFunctionInfo = ty.functions.toArray()[0]

    // 获取全局函数的泛型参数信息
    let genericTypeInfo = globalFunctionInfo.genericParams.toArray()[0]

    // 用另一种方式获取泛型参数信息
    let arr: Array<TypeInfo> = [TypeInfo.get("std.core.String"), genericTypeInfo]
    let globalFunctionInfoOtherWay = ty.getFunction("myFunc", arr)
    let genericTypeInfoOtherWay = globalFunctionInfoOtherWay.genericParams.toArray()[0]
    println("泛型类型信息是否相等: ${genericTypeInfo == genericTypeInfoOtherWay}")
    return
}

运行结果：

泛型类型信息是否相等: true

class GlobalFunctionInfo

public class GlobalFunctionInfo <: Equatable<GlobalFunctionInfo> & Hashable & ToString {}

功能：描述全局函数信息。

父类型：

prop annotations

public prop annotations: Collection<Annotation>

功能：获取所有 GlobalFunctionInfo 对应的全局函数的自定义注解，返回对应集合。

类型：Collection<Annotation>

示例：

package test

import std.reflect.*

@MyAnnotation
public func myFunc<T>(str: String, toStr: T): Unit where T <: ToString {
    println("${str}: ${toStr}")
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的第一个全局函数信息
    let globalFunctionInfo = ty.functions.toArray()[0]

    // 获取全局函数的注解信息
    let annotations = globalFunctionInfo.annotations

    // 遍历注解信息
    for (annotation in annotations) {
        let anno = (annotation as MyAnnotation).getOrThrow()
        println("Annotation: ${anno.data}")
    }
    return
}

@Annotation
public class MyAnnotation {
    public let data: String
    public const init() {
        this.data = "MyAnnotation's data"
    }
}

运行结果：

Annotation: MyAnnotation's data

prop genericParams

public prop genericParams: Collection<GenericTypeInfo>

功能：获取该 GlobalFunctionInfo 对应的全局函数的泛型参数信息列表。

类型：Collection<GenericTypeInfo>

异常：

InfoNotFoundException - GlobalFunctionInfo 没有泛型参数时抛出异常。

示例：

package test

import std.reflect.*

// 定义一个带泛型参数的全局函数
public func genericFunc<T>(value: T): T {
    return value
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的第一个全局函数信息
    let globalFunctionInfo = ty.functions.toArray()[0]

    // 获取全局函数的泛型参数信息
    let genericParams = globalFunctionInfo.genericParams
    println("泛型参数数量: ${genericParams.size}")

    // 遍历泛型参数
    for (param in genericParams) {
        println("泛型参数名称: ${param.name}")
    }

    return
}

运行结果：

泛型参数数量: 1
泛型参数名称: T

prop name

public prop name: String

功能：获取该 GlobalFunctionInfo 对应的全局函数的名称。

类型：String

示例：

package test

import std.reflect.*

// 定义一个全局函数
public func myFunction(value: Int64): Int64 {
    return value + 1
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的第一个全局函数信息
    let globalFunctionInfo = ty.functions.toArray()[0]

    // 获取全局函数的名称
    let name = globalFunctionInfo.name
    println("全局函数名称: ${name}")

    return
}

运行结果：

全局函数名称: myFunction

prop parameters

public prop parameters: ReadOnlyList<ParameterInfo>

功能：获取该 GlobalFunctionInfo 对应的全局函数的参数信息列表。

类型：ReadOnlyList<ParameterInfo>

示例：

package test

import std.reflect.*

// 定义一个带多个参数的全局函数
public func myFunction(str: String, num: Int64): Unit {
    println("String: ${str}, Int64: ${num}")
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的第一个全局函数信息
    let globalFunctionInfo = ty.functions.toArray()[0]

    // 获取全局函数的参数信息列表
    let parameters = globalFunctionInfo.parameters
    println("参数数量: ${parameters.size}")

    // 遍历参数信息
    for (param in parameters) {
        println("参数名称: ${param.name}")
    }

    return
}

运行结果：

参数数量: 2
参数名称: str
参数名称: num

prop returnType

public prop returnType: TypeInfo

功能：获取该 GlobalFunctionInfo 对应的全局函数的返回类型的类型信息。

类型：TypeInfo

示例：

package test

import std.reflect.*

// 定义一个有返回值的全局函数
public func myFunction(value: Int64): String {
    return "Value is ${value}"
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的第一个全局函数信息
    let globalFunctionInfo = ty.functions.toArray()[0]

    // 获取全局函数的返回类型信息
    let returnType = globalFunctionInfo.returnType
    println("返回类型名称: ${returnType.name}")

    return
}

运行结果：

返回类型名称: String

func apply(Array<Any>)

public func apply(args: Array<Any>): Any

功能：调用该 GlobalFunctionInfo 对应的全局函数，传入实参列表，返回调用结果。

参数：

args: Array<Any> - 实参列表。

返回值：

Any - 该全局函数的调用结果。

异常：

InvocationTargetException - 如果存在泛型参数的函数调用了该方法，则抛出异常。
IllegalArgumentException - 如果实参列表中的实参的数目与该全局函数信息 GlobalFunctionInfo 所对应的全局函数的形参列表中的形参的数目不等，则抛出异常。
IllegalTypeException - 如果实参列表中的任何一个实参的运行时类型不是该全局函数信息所对应的全局函数的对应形参的声明类型的子类型，则抛出异常。
Exception - 如果被调用的全局函数信息所对应全局函数内部抛出异常，则该异常将被封装为 Exception 异常并抛出。

示例：

package test

import std.reflect.*

// 定义一个简单的全局函数
public func add(a: Int64, b: Int64): Int64 {
    return a + b
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的第一个全局函数信息
    let globalFunctionInfo = ty.functions.toArray()[0]

    // 准备参数
    let args: Array<Any> = [10, 20]

    // 调用全局函数
    let result = globalFunctionInfo.apply(args)

    // 将结果转换为 Int64 类型
    let intResult = result as Int64
    println("调用结果: ${intResult}")

    return
}

运行结果：

调用结果: Some(30)

func apply(Array<TypeInfo>, Array<Any>)

public func apply(genericTypeArgs: Array<TypeInfo>, args: Array<Any>): Any

功能：调用该 GlobalFunctionInfo 对应的全局泛型函数，传入泛型参数类型列表和实参列表，返回调用结果。

参数：

genericTypeArgs: Array<TypeInfo> - 泛型参数类型列表。
args: Array<Any> - 实参列表。

返回值：

Any - 该全局函数的调用结果。

异常：

InvocationTargetException - 如果非泛型函数调用了该方法，则抛出异常。
IllegalArgumentException - 如果实参列表中的实参的数目与该全局函数信息 GlobalFunctionInfo 所对应的全局函数的形参列表中的形参的数目不等，则抛出异常。
IllegalArgumentException - 如果函数泛型参数列表 genericTypeArgs 中的参数数目与该全局函数信息所对应的全局函数的泛型参数列表 genericParams 中的参数数目不等，则抛出异常。
IllegalTypeException - 如果实参列表中的任何一个实参的运行时类型不是该全局函数信息所对应的全局函数的对应形参的声明类型的子类型，则抛出异常。
IllegalTypeException - 如果传入的实参列表和泛型参数类型列表 genericTypeArgs 不满足该全局函数信息所对应的全局函数的参数的类型约束，则抛出异常。
Exception - 如果被调用的全局函数信息所对应全局函数内部抛出异常，则该异常将被封装为 Exception 异常并抛出。

示例：

package test

import std.reflect.*

// 定义一个泛型全局函数
public func genericFunc<T>(value: T): T {
    return value
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的第一个全局函数信息
    let globalFunctionInfo = ty.functions.toArray()[0]

    // 准备泛型参数类型列表
    let genericTypeArgs: Array<TypeInfo> = [PrimitiveTypeInfo.get("Int64")]

    // 准备参数
    let args: Array<Any> = [42]

    // 调用泛型全局函数
    let result = globalFunctionInfo.apply(genericTypeArgs, args)

    // 将结果转换为 Int64 类型
    let intResult = result as Int64
    println("调用结果: ${intResult}")

    return
}

运行结果：

调用结果: Some(42)

func findAllAnnotations<T>() where T <: Annotation

public func findAllAnnotations<T>(): Array<T> where T <: Annotation

功能：获取所有指定注解名称的自定义注解（通过泛型筛选）。

返回值：

Array<T> - 若无指定 T 类型的注解时，返回空数组；若有相关注解时，将所有该类型注解对象构成的数组返回。

示例：

package test

import std.reflect.*

@MyAnnotation
public func myFunction(): Unit {
    println("Hello, World!")
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的第一个全局函数信息
    let globalFunctionInfo = ty.functions.toArray()[0]

    // 查找所有 MyAnnotation 类型的注解
    let annotations = globalFunctionInfo.findAllAnnotations<MyAnnotation>()
    println("找到的注解数量: ${annotations.size}")

    return
}

@Annotation
public class MyAnnotation {
    public const init() {}
}

运行结果：

找到的注解数量: 1

func findAnnotation<T>() where T <: Annotation

public func findAnnotation<T>(): ?T where T <: Annotation

功能：尝试获取指定注解名称的自定义注解（通过泛型筛选）。

返回值：

?T - 如果成功匹配则返回该注解，重复标注或者无法匹配时返回 None。

示例：

package test

import std.reflect.*

@MyAnnotation
public func myFunction(): Unit {
    println("Hello, World!")
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的第一个全局函数信息
    let globalFunctionInfo = ty.functions.toArray()[0]

    // 查找 MyAnnotation 类型的注解
    let annotation = globalFunctionInfo.findAnnotation<MyAnnotation>()

    // 检查是否找到了注解
    if (annotation.isSome()) {
        println("找到了 MyAnnotation 注解")
    } else {
        println("未找到 MyAnnotation 注解")
    }

    return
}

@Annotation
public class MyAnnotation {
    public const init() {}
}

运行结果：

找到了 MyAnnotation 注解

func getAllAnnotations()

public func getAllAnnotations(): Array<Annotation>

功能：获取作用于该全局函数的所有自定义注解。

返回值：

Array<Annotation> - 作用于该对象的所有注解。

示例：

package test

import std.reflect.*

@MyAnnotation
public func myFunction(): Unit {
    println("Hello, World!")
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的第一个全局函数信息
    let globalFunctionInfo = ty.functions.toArray()[0]

    // 获取所有注解
    let allAnnotations = globalFunctionInfo.getAllAnnotations()
    println("注解总数: ${allAnnotations.size}")

    return
}

@Annotation
public class MyAnnotation {
    public const init() {}
}

运行结果：

注解总数: 1

func hashCode()

public func hashCode(): Int64

功能：获取该全局函数信息的哈希值。

返回值：

Int64 - 该全局函数信息的哈希值。

示例：

package test

import std.reflect.*

public func myFunction(): Unit {
    println("Hello, World!")
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的第一个全局函数信息
    let globalFunctionInfo = ty.functions.toArray()[0]

    // 获取全局函数信息的哈希值
    let hashCode = globalFunctionInfo.hashCode()
    println("哈希值: ${hashCode}")

    return
}

可能的运行结果：

哈希值: 93955636542272

func toString()

public func toString(): String

功能：获取字符串形式的该全局函数信息。

返回值：

String - 字符串形式的该全局函数信息。

示例：

package test

import std.reflect.*

public func myFunction(): Unit {
    println("Hello, World!")
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的第一个全局函数信息
    let globalFunctionInfo = ty.functions.toArray()[0]

    // 获取全局函数信息的字符串表示
    let str = globalFunctionInfo.toString()
    println("字符串表示: ${str}")

    return
}

运行结果：

字符串表示: func myFunction(): Unit

operator func !=(GlobalFunctionInfo)

public operator func !=(other: GlobalFunctionInfo): Bool

功能：判断该全局函数信息与给定的另一个全局函数信息是否不等。

参数：

other: GlobalFunctionInfo - 被比较相等性的另一个全局函数信息。

返回值：

Bool - 如果该全局函数信息与另一个不等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public func function1(): Unit {
    println("Function 1")
}

public func function2(): Unit {
    println("Function 2")
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的前两个全局函数信息
    let globalFunctionInfos = ty.functions.toArray()
    let function1Info = globalFunctionInfos[0]
    let function2Info = globalFunctionInfos[1]

    // 比较两个不同的全局函数信息
    let result = function1Info != function2Info
    println("两个不同的全局函数信息不相等: ${result}")

    // 比较相同的全局函数信息
    let result2 = function1Info != function1Info
    println("相同的全局函数信息不相等: ${result2}")

    return
}

运行结果：

两个不同的全局函数信息不相等: true
相同的全局函数信息不相等: false

operator func ==(GlobalFunctionInfo)

public operator func ==(other: GlobalFunctionInfo): Bool

功能：判断该全局函数信息与给定的另一个全局函数信息是否相等。

参数：

other: GlobalFunctionInfo - 被比较相等性的另一个全局函数信息。

返回值：

Bool - 如果该全局函数信息与另一个相等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public func function1(): Unit {
    println("Function 1")
}

public func function2(): Unit {
    println("Function 2")
}

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的前两个全局函数信息
    let globalFunctionInfos = ty.functions.toArray()
    let function1Info = globalFunctionInfos[0]
    let function2Info = globalFunctionInfos[1]

    // 比较两个不同的全局函数信息
    let result = function1Info == function2Info
    println("两个不同的全局函数信息相等: ${result}")

    // 比较相同的全局函数信息
    let result2 = function1Info == function1Info
    println("相同的全局函数信息相等: ${result2}")

    return
}

运行结果：

两个不同的全局函数信息相等: false
相同的全局函数信息相等: true

class GlobalVariableInfo

public class GlobalVariableInfo <: Equatable<GlobalVariableInfo> & Hashable & ToString {}

功能：描述全局变量信息。

父类型：

prop annotations

public prop annotations: Collection<Annotation>

功能：获取所有作用于该 GlobalVariableInfo 对应的全局变量的自定义注解，返回对应集合。

类型：Collection<Annotation>

示例：

package test

import std.reflect.*

@MyAnnotation
public var myGlobalVar: Int64 = 42

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的全局变量信息
    let globalVariables = ty.variables
    println("全局变量数量: ${globalVariables.size}")

    // 获取第一个全局变量信息
    let globalVariableInfo = globalVariables.toArray()[0]

    // 获取全局变量的注解信息
    let annotations = globalVariableInfo.annotations
    println("注解数量: ${annotations.size}")

    return
}

@Annotation
public class MyAnnotation {
    public const init() {}
}

运行结果：

全局变量数量: 1
注解数量: 1

prop name

public prop name: String

功能：获取该 GlobalVariableInfo 对应的全局变量的名称。

类型：String

示例：

package test

import std.reflect.*

public var myGlobalVar: Int64 = 42

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的全局变量信息
    let globalVariables = ty.variables
    println("全局变量数量: ${globalVariables.size}")

    // 获取第一个全局变量信息
    let globalVariableInfo = globalVariables.toArray()[0]

    // 获取全局变量的名称
    let name = globalVariableInfo.name
    println("全局变量名称: ${name}")

    return
}

运行结果：

全局变量数量: 1
全局变量名称: myGlobalVar

prop typeInfo

public prop typeInfo: TypeInfo

功能：获取该 GlobalVariableInfo 对应的全局变量的声明类型的类型信息。

类型：TypeInfo

示例：

package test

import std.reflect.*

public var myGlobalVar: Int64 = 42

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的全局变量信息
    let globalVariables = ty.variables
    println("全局变量数量: ${globalVariables.size}")

    // 获取第一个全局变量信息
    let globalVariableInfo = globalVariables.toArray()[0]

    // 获取全局变量的类型信息
    let typeInfo = globalVariableInfo.typeInfo
    println("全局变量类型名称: ${typeInfo.name}")

    return
}

运行结果：

全局变量数量: 1
全局变量类型名称: Int64

func findAllAnnotations<T>() where T <: Annotation

public func findAllAnnotations<T>(): Array<T> where T <: Annotation

功能：获取所有指定注解名称的自定义注解（通过泛型筛选）。

返回值：

Array<T> - 若无指定 T 类型的注解时，返回空数组；若有相关注解时，将所有该类型注解对象构成的数组返回。

示例：

package test

import std.reflect.*

@MyAnnotation
public var myGlobalVar: Int64 = 42

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的全局变量信息
    let globalVariables = ty.variables
    println("全局变量数量: ${globalVariables.size}")

    // 获取第一个全局变量信息
    let globalVariableInfo = globalVariables.toArray()[0]

    // 查找所有 MyAnnotation 类型的注解
    let annotations = globalVariableInfo.findAllAnnotations<MyAnnotation>()
    println("找到的注解数量: ${annotations.size}")

    return
}

@Annotation
public class MyAnnotation {
    public const init() {}
}

运行结果：

全局变量数量: 1
找到的注解数量: 1

func findAnnotation<T>() where T <: Annotation

public func findAnnotation<T>(): ?T where T <: Annotation

功能：尝试获取指定注解名称的自定义注解（通过泛型筛选）。

返回值：

?T - 如果成功匹配则返回该注解，重复标注或者无法匹配时返回 None。

示例：

package test

import std.reflect.*

@MyAnnotation
public var myGlobalVar: Int64 = 42

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的全局变量信息
    let globalVariables = ty.variables
    println("全局变量数量: ${globalVariables.size}")

    // 获取第一个全局变量信息
    let globalVariableInfo = globalVariables.toArray()[0]

    // 查找 MyAnnotation 类型的注解
    let annotation = globalVariableInfo.findAnnotation<MyAnnotation>()

    // 检查是否找到了注解
    if (annotation.isSome()) {
        println("找到了 MyAnnotation 注解")
    } else {
        println("未找到 MyAnnotation 注解")
    }

    return
}

@Annotation
public class MyAnnotation {
    public const init() {}
}

运行结果：

全局变量数量: 1
找到了 MyAnnotation 注解

func getAllAnnotations()

public func getAllAnnotations(): Array<Annotation>

功能：获取作用于该对象的所有自定义注解。

返回值：

Array<Annotation> - 作用于该对象的所有注解。

示例：

package test

import std.reflect.*

@MyAnnotation
public var myGlobalVar: Int64 = 42

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的全局变量信息
    let globalVariables = ty.variables
    println("全局变量数量: ${globalVariables.size}")

    // 获取第一个全局变量信息
    let globalVariableInfo = globalVariables.toArray()[0]

    // 获取所有注解
    let allAnnotations = globalVariableInfo.getAllAnnotations()
    println("注解总数: ${allAnnotations.size}")

    return
}

@Annotation
public class MyAnnotation {
    public const init() {}
}

运行结果：

全局变量数量: 1
注解总数: 1

func getValue()

public func getValue(): Any

功能：获取该 GlobalVariableInfo 对应的全局变量的值。

返回值：

Any - 该全局变量的值。

示例：

package test

import std.reflect.*

public var myGlobalVar: Int64 = 42

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的全局变量信息
    let globalVariables = ty.variables
    println("全局变量数量: ${globalVariables.size}")

    // 获取第一个全局变量信息
    let globalVariableInfo = globalVariables.toArray()[0]

    // 获取全局变量的值
    let value = globalVariableInfo.getValue()

    // 将值转换为 Int64 类型
    let intValue = value as Int64
    println("全局变量的值: ${intValue}")

    return
}

运行结果：

全局变量数量: 1
全局变量的值: Some(42)

func hashCode()

public func hashCode(): Int64

功能：获取该全局变量信息的哈希值。

返回值：

Int64 - 该全局变量信息的哈希值。

示例：

package test

import std.reflect.*

public var myGlobalVar: Int64 = 42

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的全局变量信息
    let globalVariables = ty.variables
    println("全局变量数量: ${globalVariables.size}")

    // 获取第一个全局变量信息
    let globalVariableInfo = globalVariables.toArray()[0]

    // 获取全局变量信息的哈希值
    let hashCode = globalVariableInfo.hashCode()
    println("哈希值: ${hashCode}")

    return
}

可能的运行结果：

全局变量数量: 1
哈希值: 94726377908864

func isMutable()

public func isMutable(): Bool

功能：判断该 GlobalVariableInfo 对应的全局变量是否可修改。

返回值：

Bool - 如果该全局变量可被修改则返回 true ，否则返回 false。

示例：

package test

import std.reflect.*

public var mutableVar: Int64 = 42
public let immutableVar: Int64 = 42

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的全局变量信息
    let globalVariables = ty.variables
    println("全局变量数量: ${globalVariables.size}")

    // 获取全局变量信息
    let globalVariableInfos = globalVariables.toArray()
    let mutableVarInfo = globalVariableInfos[0]
    let immutableVarInfo = globalVariableInfos[1]

    // 检查全局变量是否可变
    let isMutable1 = mutableVarInfo.isMutable()
    println("mutableVar 是否可变: ${isMutable1}")

    let isMutable2 = immutableVarInfo.isMutable()
    println("immutableVar 是否可变: ${isMutable2}")

    return
}

运行结果：

全局变量数量: 2
mutableVar 是否可变: true
immutableVar 是否可变: false

func setValue(Any)

public func setValue(newValue: Any): Unit

功能：设置该 GlobalVariableInfo 对应的全局变量的值。

参数：

newValue: Any - 新的值。

异常：

IllegalSetException - 如果该全局变量信息所对应的全局变量不可修改，则抛出异常。
IllegalTypeException - 如果新值 newValue 的运行时类型不是全局变量信息所对应的全局变量的声明类型的子类型，则抛出异常。

示例：

package test

import std.reflect.*

public var myGlobalVar: Int64 = 42

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的全局变量信息
    let globalVariables = ty.variables
    println("全局变量数量: ${globalVariables.size}")

    // 获取第一个全局变量信息
    let globalVariableInfo = globalVariables.toArray()[0]

    // 获取全局变量的当前值
    let currentValue = globalVariableInfo.getValue() as Int64
    println("全局变量的当前值: ${currentValue}")

    // 设置全局变量的新值
    globalVariableInfo.setValue(100)

    // 获取全局变量的新值
    let newValue = globalVariableInfo.getValue() as Int64
    println("全局变量的新值: ${newValue}")

    return
}

运行结果：

全局变量数量: 1
全局变量的当前值: Some(42)
全局变量的新值: Some(100)

func toString()

public func toString(): String

功能：获取字符串形式的该全局变量信息。

返回值：

String - 字符串形式的该全局变量信息。

示例：

package test

import std.reflect.*

public var myGlobalVar: Int64 = 42

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的全局变量信息
    let globalVariables = ty.variables
    println("全局变量数量: ${globalVariables.size}")

    // 获取第一个全局变量信息
    let globalVariableInfo = globalVariables.toArray()[0]

    // 获取全局变量信息的字符串表示
    let str = globalVariableInfo.toString()
    println("字符串表示: ${str}")

    return
}

运行结果：

全局变量数量: 1
字符串表示: myGlobalVar: Int64

operator func !=(GlobalVariableInfo)

public operator func !=(other: GlobalVariableInfo): Bool

功能：判断该全局变量信息与给定的另一个全局变量信息是否不等。

参数：

other: GlobalVariableInfo - 被比较相等性的另一个全局变量信息。

返回值：

Bool - 如果该全局变量信息与另一个不等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public var globalVar1: Int64 = 42
public var globalVar2: Int64 = 100

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的全局变量信息
    let globalVariables = ty.variables
    println("全局变量数量: ${globalVariables.size}")

    // 获取全局变量信息
    let globalVariableInfos = globalVariables.toArray()
    let var1Info = globalVariableInfos[0]
    let var2Info = globalVariableInfos[1]

    // 比较两个不同的全局变量信息
    let result = var1Info != var2Info
    println("两个不同的全局变量信息不相等: ${result}")

    // 比较相同的全局变量信息
    let result2 = var1Info != var1Info
    println("相同的全局变量信息不相等: ${result2}")

    return
}

运行结果：

全局变量数量: 2
两个不同的全局变量信息不相等: true
相同的全局变量信息不相等: false

operator func ==(GlobalVariableInfo)

public operator func ==(other: GlobalVariableInfo): Bool

功能：判断该全局变量信息与给定的另一个全局变量信息是否相等。

参数：

other: GlobalVariableInfo - 被比较相等性的另一个全局变量信息。

返回值：

Bool - 如果该全局变量信息与另一个相等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public var globalVar1: Int64 = 42
public var globalVar2: Int64 = 100

main(): Unit {
    // 获取 test 包的信息
    let ty = PackageInfo.get("test")

    // 获取包中的全局变量信息
    let globalVariables = ty.variables
    println("全局变量数量: ${globalVariables.size}")

    // 获取全局变量信息
    let globalVariableInfos = globalVariables.toArray()
    let var1Info = globalVariableInfos[0]
    let var2Info = globalVariableInfos[1]

    // 比较两个不同的全局变量信息
    let result = var1Info == var2Info
    println("两个不同的全局变量信息相等: ${result}")

    // 比较相同的全局变量信息
    let result2 = var1Info == var1Info
    println("相同的全局变量信息相等: ${result2}")

    return
}

运行结果：

全局变量数量: 2
两个不同的全局变量信息相等: false
相同的全局变量信息相等: true

class InstanceFunctionInfo

public class InstanceFunctionInfo <: Equatable<InstanceFunctionInfo> & Hashable & ToString {}

功能：描述实例成员函数信息。

父类型：

prop annotations

public prop annotations: Collection<Annotation>

功能：获取所有作用于该 InstanceFunctionInfo 对应的实例成员函数的自定义注解，返回对应集合。

类型：Collection<Annotation>

示例：

package test

import std.reflect.*

public class MyClass {
    @MyAnnotation
    public func myMethod(): Int64 {
        return 42
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取实例成员函数信息
    let instanceFunctionInfo = classInfo.getInstanceFunction("myMethod")

    // 获取注解信息
    let annotations = instanceFunctionInfo.annotations
    println("注解数量: ${annotations.size}")

    return
}

@Annotation
public class MyAnnotation {
    public const init() {}
}

运行结果：

注解数量: 1

prop genericParams

public prop genericParams: Collection<GenericTypeInfo>

功能：获取该 InstanceFunctionInfo 对应的实例成员函数的泛型参数信息列表。

类型：Collection<GenericTypeInfo>

异常：

InfoNotFoundException - GlobalFunctionInfo 没有泛型参数时抛出异常。

示例：

package test

import std.reflect.*

public class MyClass {
    public func genericMethod<T>(value: T): T {
        return value
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取所有实例成员函数信息
    let functions = classInfo.instanceFunctions
    println("实例成员函数数量: ${functions.size}")

    // 遍历所有实例成员函数
    for (funcInfo in functions) {
        println("函数名称: ${funcInfo.name}")
        // 尝试获取泛型参数信息
        try {
            let genericParams = funcInfo.genericParams
            println("泛型参数数量: ${genericParams.size}")

            // 遍历泛型参数
            for (param in genericParams) {
                println("泛型参数名称: ${param.name}")
            }
        } catch (e: InfoNotFoundException) {
            println("该函数没有泛型参数")
        }
    }

    return
}

运行结果：

实例成员函数数量: 1
函数名称: genericMethod
泛型参数数量: 1
泛型参数名称: T

prop modifiers

public prop modifiers: Collection<ModifierInfo>

功能：获取该 InstanceFunctionInfo 对应的实例成员函数所拥有的所有修饰符的信息，返回对应集合。

类型：Collection<ModifierInfo>

示例：

package test

import std.reflect.*

public open class MyClass {
    public open func publicMethod(): Int64 {
        return 42
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取实例成员函数信息
    let instanceFunctionInfo = classInfo.getInstanceFunction("publicMethod")

    // 获取修饰符信息
    let modifiers = instanceFunctionInfo.modifiers
    println("修饰符数量: ${modifiers.size}")

    return
}

运行结果：

修饰符数量: 1

prop name

public prop name: String

功能：获取该 InstanceFunctionInfo 对应的实例成员函数的名称。

类型：String

示例：

package test

import std.reflect.*

public class MyClass {
    public func myMethod(): Int64 {
        return 42
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取实例成员函数信息
    let instanceFunctionInfo = classInfo.getInstanceFunction("myMethod")

    // 获取函数名称
    let name = instanceFunctionInfo.name
    println("函数名称: ${name}")

    return
}

运行结果：

函数名称: myMethod

prop parameters

public prop parameters: ReadOnlyList<ParameterInfo>

功能：获取该 InstanceFunctionInfo 对应的实例成员函数的参数信息列表。

类型：ReadOnlyList<ParameterInfo>

示例：

package test

import std.reflect.*

public class MyClass {
    public func myMethod(a: Int64, b: String): Int64 {
        return a
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取所有实例成员函数
    let functions = classInfo.instanceFunctions
    println("实例成员函数数量: ${functions.size}")

    // 遍历所有实例成员函数
    for (funcInfo in functions) {
        println("函数名称: ${funcInfo.name}")

        // 获取参数信息
        let parameters = funcInfo.parameters
        println("参数数量: ${parameters.size}")

        // 遍历参数
        for (param in parameters) {
            println("参数名称: ${param.name}")
        }
    }

    return
}

运行结果：

实例成员函数数量: 1
函数名称: myMethod
参数数量: 2
参数名称: a
参数名称: b

prop returnType

public prop returnType: TypeInfo

功能：获取该 InstanceFunctionInfo 对应的实例成员函数的返回值类型的类型信息。

类型：TypeInfo

示例：

package test

import std.reflect.*

public class MyClass {
    public func myMethod(a: Int64, b: String): Int64 {
        return a
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取所有实例成员函数
    let functions = classInfo.instanceFunctions
    println("实例成员函数数量: ${functions.size}")

    // 遍历所有实例成员函数
    for (funcInfo in functions) {
        println("函数名称: ${funcInfo.name}")

        // 获取返回值类型信息
        let returnType = funcInfo.returnType
        println("返回值类型: ${returnType.name}")
    }

    return
}

运行结果：

实例成员函数数量: 1
函数名称: myMethod
返回值类型: Int64

func apply(Any, Array<Any>)

public func apply(instance: Any, args: Array<Any>): Any

功能：调用该 InstanceFunctionInfo 对应实例成员函数，指定实例并传入实参列表，返回调用结果。

参数：

instance: Any - 实例。
args: Array<Any> - 实参列表。

返回值：

Any - 该实例成员函数的调用结果。

异常：

InvocationTargetException - 如果存在泛型参数的函数调用了该方法，则抛出异常。
InvocationTargetException - 如果该实例成员函数信息所对应的实例成员函数是抽象的，或不存在相应的函数实现，则抛出异常。
IllegalArgumentException - 如果实参列表中的实参的数目与该实例成员函数信息所对应的实例成员函数的形参列表中的形参的数目不等，则抛出异常。
IllegalTypeException - 如果实例 instance 的运行时类型与该实例成员函数信息所对应的实例成员函数所属的类型不相同，则抛出异常。
IllegalTypeException - 如果实参列表中的任何一个实参的运行时类型不是该实例成员函数信息所对应的实例成员函数的对应形参的声明类型的子类型，则抛出异常。
Exception - 如果被调用的实例成员函数信息所对应的实例成员函数内部抛出异常，则该异常将被封装为 Exception 异常并抛出。

示例：

package test

import std.reflect.*

public class MyClass {
    public var value: Int64 = 0

    public func setValue(newValue: Int64): Unit {
        this.value = newValue
    }

    public func getValue(): Int64 {
        return this.value
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 创建实例
    let instance = MyClass()

    // 获取实例成员函数
    let setValueFunc = classInfo.getInstanceFunction("setValue", [PrimitiveTypeInfo.get("Int64")])
    let getValueFunc = classInfo.getInstanceFunction("getValue", [])

    // 准备参数
    let args: Array<Any> = [42]

    // 调用 setValue 函数
    setValueFunc.apply(instance, args)
    println("setValue 函数调用成功")

    // 调用 getValue 函数
    let result = getValueFunc.apply(instance, [])

    // 将结果转换为 Int64 类型
    let intResult = result as Int64
    println("getValue 函数调用结果: ${intResult}")

    return
}

运行结果：

setValue 函数调用成功
getValue 函数调用结果: Some(42)

func apply(Any, Array<TypeInfo>, Array<Any>)

public func apply(instance: Any, genericTypeArgs: Array<TypeInfo>, args: Array<Any>): Any

功能：调用该 InstanceFunctionInfo 对应泛型成员函数，指定实例并传入泛型参数的类型列表和参数列表，返回调用结果。

参数：

instance: Any - 实例。
genericTypeArgs: Array<TypeInfo> - 泛型参数类型信息列表。
args: Array<Any> - 泛型参数列表。

返回值：

Any - 该实例泛型函数的调用结果。

异常：

InvocationTargetException - 如果该函数信息对应的成员函数是 abstract 或不存在函数体，则会抛出异常。
InvacationTargetException - 如果非泛型函数调用了此方法，则抛出异常。
IllegalTypeException - 如果实例 instance 的运行时类型与该成员函数信息所对应的成员函数所属的类型不相同，则抛出异常。
IllegalArgumentException - 如果实参列表中的实参的数目与该成员函数信息所对应的成员函数的形参列表中的形参的数目不等，则抛出异常。
IllegalArgumentException - 如果函数泛型参数列表 genericTypeArgs 中的参数数目与该成员函数信息所对应的成员函数的泛型参数列表 genericParams 中的参数数目不等，则抛出异常。
IllegalTypeException - 如果参数列表中的任何一个参数的运行时类型不是该实例成员函数信息所对应的实例成员函数的对应形参的声明类型的子类型，则抛出异常。
IllegalTypeException - 如果传入的参数列表和泛型参数类型列表 genericTypeArgs 不满足该成员函数信息所对应的成员函数的参数的类型约束，则抛出异常。
Exception - 如果被调用的实例成员函数信息所对应的实例成员函数内部抛出异常，则该异常将被封装为 Exception 异常并抛出。

示例：

package test

import std.reflect.*

public class MyClass {
    public func genericMethod<T>(value: T): T {
        return value
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 创建实例
    let instance = MyClass()

    // 获取所有实例成员函数
    let functions = classInfo.instanceFunctions

    // 查找 genericMethod 函数
    var genericFuncOpt: Option<InstanceFunctionInfo> = None

    for (funcInfo in functions) {
        if (funcInfo.name == "genericMethod") {
            genericFuncOpt = Some(funcInfo)
        }
    }

    // 准备泛型参数类型列表
    let genericTypeArgs: Array<TypeInfo> = [PrimitiveTypeInfo.get("Int64")]

    // 准备参数
    let args: Array<Any> = [42]

    // 调用 genericMethod 函数
    if (let Some(genericFunc) <- genericFuncOpt) {
        let result = genericFunc.apply(instance, genericTypeArgs, args)

        // 将结果转换为 Int64 类型
        let intResult = result as Int64
        println("genericMethod 函数调用结果: ${intResult}")
    }

    return
}

运行结果：

genericMethod 函数调用结果: Some(42)

func findAllAnnotations<T>() where T <: Annotation

public func findAllAnnotations<T>(): Array<T> where T <: Annotation

功能：获取所有指定注解名称的自定义注解（通过泛型筛选）。

返回值：

Array<T> - 若无指定 T 类型的注解时，返回空数组；若有相关注解时，将所有该类型注解对象构成的数组返回。

示例：

package test

import std.reflect.*

public class MyClass {
    @MyAnnotation
    @AnotherAnnotation
    public func myMethod(): Int64 {
        return 42
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取实例成员函数信息
    let instanceFunctionInfo = classInfo.getInstanceFunction("myMethod")

    // 查找所有 MyAnnotation 注解
    let myAnnotations = instanceFunctionInfo.findAllAnnotations<MyAnnotation>()
    println("MyAnnotation 注解数量: ${myAnnotations.size}")

    // 查找所有 AnotherAnnotation 注解
    let anotherAnnotations = instanceFunctionInfo.findAllAnnotations<AnotherAnnotation>()
    println("AnotherAnnotation 注解数量: ${anotherAnnotations.size}")

    return
}

@Annotation
public class MyAnnotation {
    public const init() {}
}

@Annotation
public class AnotherAnnotation {
    public const init() {}
}

运行结果：

MyAnnotation 注解数量: 1
AnotherAnnotation 注解数量: 1

func findAnnotation<T>() where T <: Annotation

public func findAnnotation<T>(): ?T where T <: Annotation

功能：尝试获取指定注解名称的自定义注解（通过泛型筛选）。

返回值：

?T - 如果成功匹配则返回该注解，重复标注或者无法匹配时返回 None。

示例：

package test

import std.reflect.*

public class MyClass {
    @MyAnnotation
    public func myMethod(): Int64 {
        return 42
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取实例成员函数信息
    let instanceFunctionInfo = classInfo.getInstanceFunction("myMethod")

    // 查找 MyAnnotation 注解
    let myAnnotation = instanceFunctionInfo.findAnnotation<MyAnnotation>()

    match (myAnnotation) {
        case Some(annotation) => println("找到了 MyAnnotation 注解")
        case None => println("未找到 MyAnnotation 注解")
    }

    // 尝试查找不存在的注解
    let anotherAnnotation = instanceFunctionInfo.findAnnotation<AnotherAnnotation>()

    match (anotherAnnotation) {
        case Some(annotation) => println("找到了 AnotherAnnotation 注解")
        case None => println("未找到 AnotherAnnotation 注解")
    }

    return
}

@Annotation
public class MyAnnotation {
    public const init() {}
}

@Annotation
public class AnotherAnnotation {
    public const init() {}
}

运行结果：

找到了 MyAnnotation 注解
未找到 AnotherAnnotation 注解

func getAllAnnotations()

public func getAllAnnotations(): Array<Annotation>

功能：获取作用于该对象的所有自定义注解。

返回值：

Array<Annotation> - 作用于该对象的所有注解。

示例：

package test

import std.reflect.*

public class MyClass {
    @MyAnnotation
    @AnotherAnnotation
    public func myMethod(): Int64 {
        return 42
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取实例成员函数信息
    let instanceFunctionInfo = classInfo.getInstanceFunction("myMethod")

    // 获取所有注解
    let allAnnotations = instanceFunctionInfo.getAllAnnotations()
    println("注解总数: ${allAnnotations.size}")

    return
}

@Annotation
public class MyAnnotation {
    public const init() {}
}

@Annotation
public class AnotherAnnotation {
    public const init() {}
}

运行结果：

注解总数: 2

func hashCode()

public func hashCode(): Int64

功能：获取该实例成员函数信息的哈希值。

返回值：

Int64 - 该实例成员函数信息的哈希值。

示例：

package test

import std.reflect.*

public class MyClass {
    public func myMethod(): Int64 {
        return 42
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取实例成员函数信息
    let instanceFunctionInfo = classInfo.getInstanceFunction("myMethod")

    // 获取哈希值
    let hashCode = instanceFunctionInfo.hashCode()
    println("哈希值: ${hashCode}")

    return
}

可能的运行结果：

哈希值: 93832974760528

func isAbstract()

public func isAbstract(): Bool

功能：判断 InstanceFunctionInfo 所对应的实例成员函数是否拥有 abstract 语义。

返回值：

Bool - 如果该实例成员函数拥有 abstract 语义则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public abstract class MyClass {
    public func method1(): Int64 {
        return 42
    }

    public func method2(): Int64
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取方法信息
    let func1 = classInfo.getInstanceFunction("method1")
    let func2 = classInfo.getInstanceFunction("method2")

    // 检查是否为抽象方法
    let isAbstract1 = func1.isAbstract()
    let isAbstract2 = func2.isAbstract()

    println("method1 是否为抽象方法: ${isAbstract1}")
    println("method2 是否为抽象方法: ${isAbstract2}")

    return
}

运行结果：

method1 是否为抽象方法: false
method2 是否为抽象方法: true

func isOpen()

public func isOpen(): Bool

功能：判断该 InstanceFunctionInfo 对应的实例成员函数是否拥有 open 语义。

返回值：

Bool - 如果该实例成员函数拥有 open 语义则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public open class MyClass {
    public func method1(): Int64 {
        return 42
    }

    public open func method2(): Int64 {
        return 42
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取方法信息
    let methodFunc1 = classInfo.getInstanceFunction("method1")
    let methodFunc2 = classInfo.getInstanceFunction("method2")

    // 检查是否为开放方法
    let isOpen1 = methodFunc1.isOpen()
    let isOpen2 = methodFunc2.isOpen()

    println("method1 是否为开放方法: ${isOpen1}")
    println("method2 是否为开放方法: ${isOpen2}")

    return
}

运行结果：

method1 是否为开放方法: false
method2 是否为开放方法: true

func toString()

public func toString(): String

功能：获取字符串形式的该实例成员函数信息。

返回值：

String - 字符串形式的该实例成员函数信息。

示例：

package test

import std.reflect.*

public class MyClass {
    public func myMethod(a: Int64, b: String): Int64 {
        return a
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取所有实例成员函数
    let functions = classInfo.instanceFunctions

    // 遍历所有实例成员函数
    for (funcInfo in functions) {
        println("函数名称: ${funcInfo.name}")

        // 获取字符串表示
        let str = funcInfo.toString()
        println("字符串表示: ${str}")
    }

    return
}

运行结果：

函数名称: myMethod
字符串表示: func myMethod(Int64, String): Int64

operator func !=(InstanceFunctionInfo)

public operator func !=(other: InstanceFunctionInfo): Bool

功能：判断该实例成员函数信息与给定的另一个实例成员函数信息是否不等。

参数：

other: InstanceFunctionInfo - 被比较相等性的另一个实例成员函数信息。

返回值：

Bool - 如果该实例成员函数信息与另一个不等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public class MyClass {
    public func method1(): Int64 {
        return 42
    }

    public func method2(): Int64 {
        return 42
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取所有实例成员函数
    let functions = classInfo.instanceFunctions
    let funcArray = functions.toArray()

    // 获取两个不同的函数信息
    let func1 = funcArray[0]
    let func2 = funcArray[1]

    // 比较两个不同的函数信息
    let result1 = func1 != func2
    println("两个不同的函数信息不相等: ${result1}")

    // 比较相同的函数信息
    let result2 = func1 != func1
    println("相同的函数信息不相等: ${result2}")

    return
}

运行结果：

两个不同的函数信息不相等: true
相同的函数信息不相等: false

operator func ==(InstanceFunctionInfo)

public operator func ==(other: InstanceFunctionInfo): Bool

功能：判断该实例成员函数信息与给定的另一个实例成员函数信息是否相等。

参数：

other: InstanceFunctionInfo - 被比较相等性的另一个实例成员函数信息。

返回值：

Bool - 如果该实例成员函数信息与另一个相等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public class MyClass {
    public func method1(): Int64 {
        return 42
    }

    public func method2(): Int64 {
        return 42
    }
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("test.MyClass")

    // 获取所有实例成员函数
    let functions = classInfo.instanceFunctions
    let funcArray = functions.toArray()

    // 获取两个不同的函数信息
    let func1 = funcArray[0]
    let func2 = funcArray[1]

    // 比较两个不同的函数信息
    let result1 = func1 == func2
    println("两个不同的函数信息相等: ${result1}")

    // 比较相同的函数信息
    let result2 = func1 == func1
    println("相同的函数信息相等: ${result2}")

    return
}

运行结果：

两个不同的函数信息相等: false
相同的函数信息相等: true

class InstancePropertyInfo

public class InstancePropertyInfo <: Equatable<InstancePropertyInfo> & Hashable & ToString {}

功能：描述实例成员属性信息。

父类型：

prop annotations

public prop annotations: Collection<Annotation>

功能：获取所有作用于该 InstancePropertyInfo 对应的实例成员属性的自定义注解，返回对应集合。

类型：Collection<Annotation>

示例：

import std.reflect.*

public class MyTestClass {
    @MyCustomAnnotation
    public prop myProperty: Int64 {
        get() {
            42
        }
    }
}

main(): Unit {
    // 获取 MyTestClass 类型信息
    let classInfo = ClassTypeInfo.get("default.MyTestClass")

    // 获取实例成员属性信息
    let propertyInfo = classInfo.getInstanceProperty("myProperty")

    // 获取注解信息
    let annotations = propertyInfo.annotations
    println("注解数量: ${annotations.size}")

    return
}

@Annotation
public class MyCustomAnnotation {
    public const init() {}
}

运行结果：

注解数量: 1

prop modifiers

public prop modifiers: Collection<ModifierInfo>

功能：获取该 InstancePropertyInfo 对应的实例成员属性所拥有的所有修饰符的信息，返回对应集合。

类型：Collection<ModifierInfo>

示例：

import std.reflect.*

public open class MyTestClass {
    public open prop myProperty: Int64 {
        get() {
            42
        }
    }
}

main(): Unit {
    // 获取 MyTestClass 类型信息
    let classInfo = ClassTypeInfo.get("default.MyTestClass")

    // 获取实例成员属性信息
    let propertyInfo = classInfo.getInstanceProperty("myProperty")

    // 获取修饰符信息
    let modifiers = propertyInfo.modifiers
    println("修饰符数量: ${modifiers.size}")

    return
}

运行结果：

修饰符数量: 1

prop name

public prop name: String

功能：获取该 InstancePropertyInfo 对应的实例成员属性的名称。

类型：String

示例：

import std.reflect.*

public class MyTestClass {
    public prop myProperty: Int64 {
        get() {
            42
        }
    }
}

main(): Unit {
    // 获取 MyTestClass 类型信息
    let classInfo = ClassTypeInfo.get("default.MyTestClass")

    // 获取实例成员属性信息
    let propertyInfo = classInfo.getInstanceProperty("myProperty")

    // 获取属性名称
    let name = propertyInfo.name
    println("属性名称: ${name}")

    return
}

运行结果：

属性名称: myProperty

prop typeInfo

public prop typeInfo: TypeInfo

功能：获取该 InstancePropertyInfo 对应的实例成员属性的声明类型的类型信息。

类型：TypeInfo

示例：

import std.reflect.*

public class MyTestClass {
    public prop myProperty: Int64 {
        get() {
            42
        }
    }
}

main(): Unit {
    // 获取 MyTestClass 类型信息
    let classInfo = ClassTypeInfo.get("default.MyTestClass")

    // 获取实例成员属性信息
    let propertyInfo = classInfo.getInstanceProperty("myProperty")

    // 获取类型信息
    let typeInfo = propertyInfo.typeInfo
    println("属性类型: ${typeInfo.name}")

    return
}

运行结果：

属性类型: Int64

func findAllAnnotations<T>() where T <: Annotation

public func findAllAnnotations<T>(): Array<T> where T <: Annotation

功能：获取所有指定注解名称的自定义注解（通过泛型筛选）。

返回值：

Array<T> - 若无指定 T 类型的注解时，返回空数组；若有相关注解时，将所有该类型注解对象构成的数组返回。

示例：

import std.reflect.*

public class MyTestClass {
    @MyCustomAnnotation
    @AnotherAnnotation
    public prop myProperty: Int64 {
        get() {
            42
        }
    }
}

main(): Unit {
    // 获取 MyTestClass 类型信息
    let classInfo = ClassTypeInfo.get("default.MyTestClass")

    // 获取实例成员属性信息
    let propertyInfo = classInfo.getInstanceProperty("myProperty")

    // 查找所有 MyCustomAnnotation 注解
    let myAnnotations = propertyInfo.findAllAnnotations<MyCustomAnnotation>()
    println("MyCustomAnnotation 注解数量: ${myAnnotations.size}")

    // 查找所有 AnotherAnnotation 注解
    let anotherAnnotations = propertyInfo.findAllAnnotations<AnotherAnnotation>()
    println("AnotherAnnotation 注解数量: ${anotherAnnotations.size}")

    return
}

@Annotation
public class MyCustomAnnotation {
    public const init() {}
}

@Annotation
public class AnotherAnnotation {
    public const init() {}
}

运行结果：

MyCustomAnnotation 注解数量: 1
AnotherAnnotation 注解数量: 1

func findAnnotation<T>() where T <: Annotation

public func findAnnotation<T>(): ?T where T <: Annotation

功能：尝试获取指定注解名称的自定义注解（通过泛型筛选）。

返回值：

?T - 如果成功匹配则返回该注解，重复标注或者无法匹配时返回 None。

示例：

import std.reflect.*

public class TestClassB {
    @CustomAnnotationA
    public prop myProperty: Int64 {
        get() {
            42
        }
    }
}

main(): Unit {
    // 获取 TestClassB 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassB")

    // 获取实例成员属性信息
    let propertyInfo = classInfo.getInstanceProperty("myProperty")

    // 查找 CustomAnnotationA 注解
    let myAnnotation = propertyInfo.findAnnotation<CustomAnnotationA>()

    match (myAnnotation) {
        case Some(_) => println("找到了 CustomAnnotationA 注解")
        case None => println("未找到 CustomAnnotationA 注解")
    }

    // 尝试查找不存在的注解
    let anotherAnnotation = propertyInfo.findAnnotation<CustomAnnotationB>()

    match (anotherAnnotation) {
        case Some(_) => println("找到了 CustomAnnotationB 注解")
        case None => println("未找到 CustomAnnotationB 注解")
    }

    return
}

@Annotation
public class CustomAnnotationA {
    public const init() {}
}

@Annotation
public class CustomAnnotationB {
    public const init() {}
}

运行结果：

找到了 CustomAnnotationA 注解
未找到 CustomAnnotationB 注解

func getAllAnnotations()

public func getAllAnnotations(): Array<Annotation>

功能：获取作用于该对象的所有自定义注解。

返回值：

Array<Annotation> - 作用于该对象的所有注解。

示例：

import std.reflect.*

public class TestClassC {
    @CustomAnnotationA
    @CustomAnnotationB
    public prop myProperty: Int64 {
        get() {
            42
        }
    }
}

main(): Unit {
    // 获取 TestClassC 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassC")

    // 获取实例成员属性信息
    let propertyInfo = classInfo.getInstanceProperty("myProperty")

    // 获取所有注解
    let allAnnotations = propertyInfo.getAllAnnotations()
    println("注解总数: ${allAnnotations.size}")

    return
}

@Annotation
public class CustomAnnotationA {
    public const init() {}
}

@Annotation
public class CustomAnnotationB {
    public const init() {}
}

运行结果：

注解总数: 2

func getValue(Any)

public func getValue(instance: Any): Any

功能：获取该 InstancePropertyInfo 对应的实例成员属性在给定实例中的值。

参数：

instance: Any - 实例。

返回值：

Any - 该实例成员属性在入参实例中的值。

异常：

IllegalTypeException - 如果入参实例运行时类型与该实例成员属性信息所对应的实例成员属性所属的类型不严格相同，则抛出异常。

示例：

import std.reflect.*

public class Rectangular {
    public var length = 4
    public prop width: Int64 {
        get() {
            5
        }
    }
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 ClassTypeInfo，也可以通过实例获取 ClassTypeInfo
    let ty = ClassTypeInfo.get("default.Rectangular")
    // 获取 InstancePropertyInfo
    var gip = ty.getInstanceProperty("width")

    // 获取实例值
    var r = Rectangular()
    var result = gip.getValue(r) as Int64
    println(result)
    return
}

运行结果：

Some(5)

func hashCode()

public func hashCode(): Int64

功能：获取该实例成员属性信息的哈希值。

返回值：

Int64 - 该实例成员属性信息的哈希值。

示例：

import std.reflect.*

public class MyTestClass {
    public prop myProperty: Int64 {
        get() {
            42
        }
    }
}

main(): Unit {
    // 获取 MyTestClass 类型信息
    let classInfo = ClassTypeInfo.get("default.MyTestClass")

    // 获取实例成员属性信息
    let propertyInfo = classInfo.getInstanceProperty("myProperty")

    // 获取哈希值
    let hashCode = propertyInfo.hashCode()
    println("哈希值: ${hashCode}")

    return
}

可能的运行结果：

哈希值: 94842408817472

func isAbstract()

public func isAbstract(): Bool

功能：判断该 InstancePropertyInfo 对应的实例成员属性是否是抽象的。

返回值：

Bool - 如果该 InstancePropertyInfo 对应的实例成员属性是抽象的，则返回 true，否则返回 false。

示例：

import std.reflect.*

public abstract class TestClassD {
    public prop property1: Int64 {
        get() {
            42
        }
    }
    public prop property2: Int64
}

main(): Unit {
    // 获取 TestClassD 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassD")

    // 获取属性信息
    let prop1 = classInfo.getInstanceProperty("property1")
    let prop2 = classInfo.getInstanceProperty("property2")

    // 检查是否为抽象属性
    let isAbstract1 = prop1.isAbstract()
    let isAbstract2 = prop2.isAbstract()

    println("property1 是否为抽象属性: ${isAbstract1}")
    println("property2 是否为抽象属性: ${isAbstract2}")

    return
}

运行结果：

property1 是否为抽象属性: false
property2 是否为抽象属性: true

func isMutable()

public func isMutable(): Bool

功能：判断该 InstancePropertyInfo 对应的实例成员属性是否可修改。

返回值：

Bool - 如果该实例成员属性信息所对应的实例成员属性可被修改则返回 true ，否则返回 false。

示例：

import std.reflect.*

public class TestClassE {
    public prop myProperty1: Int64 {
        get() {
            42
        }
    }
    public mut prop myProperty2: Int64 {
        get() {
            42
        }
        set(v) {}
    }
}

main(): Unit {
    // 获取 TestClassE 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassE")

    // 获取属性信息
    let myProp1 = classInfo.getInstanceProperty("myProperty1")
    let myProp2 = classInfo.getInstanceProperty("myProperty2")

    // 检查是否可修改
    let isMutable1 = myProp1.isMutable()
    let isMutable2 = myProp2.isMutable()

    println("myProperty1 是否可修改: ${isMutable1}")
    println("myProperty2 是否可修改: ${isMutable2}")

    return
}

运行结果：

myProperty1 是否可修改: false
myProperty2 是否可修改: true

func isOpen()

public func isOpen(): Bool

功能：判断该 InstancePropertyInfo 对应的实例成员属性是否拥有 open 语义。

返回值：

Bool - 如果该 InstancePropertyInfo 对应的实例成员属性拥有 open 语义则返回 true，否则返回 false。

示例：

import std.reflect.*

public open class TestClassF {
    public prop property1: Int64 {
        get() {
            42
        }
    }

    public open prop property2: Int64 {
        get() {
            42
        }
    }
}

main(): Unit {
    // 获取 TestClassF 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassF")

    // 获取属性信息
    let prop1 = classInfo.getInstanceProperty("property1")
    let prop2 = classInfo.getInstanceProperty("property2")

    // 检查是否为开放属性
    let isOpen1 = prop1.isOpen()
    let isOpen2 = prop2.isOpen()

    println("property1 是否为开放属性: ${isOpen1}")
    println("property2 是否为开放属性: ${isOpen2}")

    return
}

运行结果：

property1 是否为开放属性: false
property2 是否为开放属性: true

func setValue(Any, Any)

public func setValue(instance: Any, newValue: Any): Unit

功能：设置该 InstancePropertyInfo 对应的实例成员属性在给定实例中的值。

参数：

instance: Any - 实例。
newValue: Any - 新值。

异常：

IllegalSetException - 如果该实例成员属性信息所对应的实例成员属性不可修改，则抛出异常。
IllegalTypeException - 如果入参实例运行时类型与该实例成员属性信息所对应的实例成员属性所属的类型不严格相同，则抛出异常。
IllegalTypeException - 如果新值 newValue 的运行时类型不是该实例成员属性信息所对应的实例成员属性的声明类型的子类型，则抛出异常。

示例：

import std.reflect.*

public class TestClassG {
    private var _myProperty: Int64 = 0
    public mut prop myProperty: Int64 {
        get() {
            _myProperty
        }
        set(v) {
            _myProperty = v
        }
    }
}

main(): Unit {
    // 创建实例
    let instance = TestClassG()

    // 获取 TestClassG 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassG")

    // 获取实例成员属性信息
    let propertyInfo = classInfo.getInstanceProperty("myProperty")

    // 设置新值
    propertyInfo.setValue(instance, 100)

    // 验证值是否设置成功
    let currentValue = propertyInfo.getValue(instance) as Int64
    println("当前值: ${currentValue}")

    return
}

运行结果：

当前值: Some(100)

func toString()

public func toString(): String

功能：获取字符串形式的该实例成员属性信息。

返回值：

String - 字符串形式的该实例成员属性信息。

示例：

import std.reflect.*

public class TestClassH {
    public prop myProperty: Int64 {
        get() {
            42
        }
    }
}

main(): Unit {
    // 获取 TestClassH 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassH")

    // 获取实例成员属性信息
    let propertyInfo = classInfo.getInstanceProperty("myProperty")

    // 获取字符串表示
    let str = propertyInfo.toString()
    println("字符串表示: ${str}")

    return
}

运行结果：

字符串表示: prop myProperty: Int64

operator func !=(InstancePropertyInfo)

public operator func !=(other: InstancePropertyInfo): Bool

功能：判断该实例成员属性信息与给定的另一个实例成员属性信息是否不等。

参数：

other: InstancePropertyInfo - 被比较相等性的另一个实例成员属性信息。

返回值：

Bool - 如果该实例成员属性信息与另一个不等则返回 true，否则返回 false。

示例：

import std.reflect.*

public class TestClassI {
    public prop property1: Int64 {
        get() {
            42
        }
    }

    public prop property2: Int64 {
        get() {
            42
        }
    }
}

main(): Unit {
    // 获取 TestClassI 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassI")

    // 获取实例成员属性信息
    let prop1 = classInfo.getInstanceProperty("property1")
    let prop2 = classInfo.getInstanceProperty("property2")

    // 比较两个不同的属性信息
    let result1 = prop1 != prop2
    println("两个不同的属性信息不相等: ${result1}")

    // 比较相同的属性信息
    let result2 = prop1 != prop1
    println("相同的属性信息不相等: ${result2}")

    return
}

运行结果：

两个不同的属性信息不相等: true
相同的属性信息不相等: false

operator func ==(InstancePropertyInfo)

public operator func ==(other: InstancePropertyInfo): Bool

功能：判断该实例成员属性信息与给定的另一个实例成员属性信息是否相等。

参数：

other: InstancePropertyInfo - 被比较相等性的另一个实例成员属性信息。

返回值：

Bool - 如果该实例成员属性信息与另一个相等则返回 true，否则返回 false。

示例：

import std.reflect.*

public class TestClassJ {
    public prop property1: Int64 {
        get() {
            42
        }
    }

    public prop property2: Int64 {
        get() {
            42
        }
    }
}

main(): Unit {
    // 获取 TestClassJ 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassJ")

    // 获取实例成员属性信息
    let prop1 = classInfo.getInstanceProperty("property1")
    let prop2 = classInfo.getInstanceProperty("property2")

    // 比较两个不同的属性信息
    let result1 = prop1 == prop2
    println("两个不同的属性信息相等: ${result1}")

    // 比较相同的属性信息
    let result2 = prop1 == prop1
    println("相同的属性信息相等: ${result2}")

    return
}

运行结果：

两个不同的属性信息相等: false
相同的属性信息相等: true

class InstanceVariableInfo

public class InstanceVariableInfo <: Equatable<InstanceVariableInfo> & Hashable & ToString {}

功能：描述实例成员变量信息。

父类型：

prop annotations

public prop annotations: Collection<Annotation>

功能：获取所有作用于该 InstanceVariableInfo 对应的实例成员变量的自定义注解，返回对应集合。

类型：Collection<Annotation>

示例：

import std.reflect.*

public class MyClass {
    @MyCustomAnnotation
    public var myVariable: Int64 = 42
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("default.MyClass")

    // 获取实例成员变量信息
    let variableInfo = classInfo.getInstanceVariable("myVariable")

    // 获取注解信息
    let annotations = variableInfo.annotations
    println("注解数量: ${annotations.size}")

    return
}

@Annotation
public class MyCustomAnnotation {
    public const init() {}
}

运行结果：

注解数量: 1

prop modifiers

public prop modifiers: Collection<ModifierInfo>

功能：获取该 InstanceVariableInfo 对应的实例成员变量所拥有的所有修饰符的信息，返回对应集合。

类型：Collection<ModifierInfo>

示例：

import std.reflect.*

public class MyClass {
    public var myVariable: Int64 = 42
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("default.MyClass")

    // 获取实例成员变量信息
    let variableInfo = classInfo.getInstanceVariable("myVariable")

    // 获取修饰符信息
    let modifiers = variableInfo.modifiers
    println("修饰符数量: ${modifiers.size}")

    return
}

运行结果：

修饰符数量: 0

prop name

public prop name: String

功能：获取该 InstanceVariableInfo 对应的实例成员变量的名称。

类型：String

示例：

import std.reflect.*

public class MyClass {
    public var myVariable: Int64 = 42
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("default.MyClass")

    // 获取实例成员变量信息
    let variableInfo = classInfo.getInstanceVariable("myVariable")

    // 获取变量名称
    let name = variableInfo.name
    println("变量名称: ${name}")

    return
}

运行结果：

变量名称: myVariable

prop typeInfo

public prop typeInfo: TypeInfo

功能：获取该 InstanceVariableInfo 对应的实例成员变量的声明类型的类型信息。

类型：TypeInfo

示例：

import std.reflect.*

public class MyClass {
    public var myVariable: Int64 = 42
}

main(): Unit {
    // 获取 MyClass 类型信息
    let classInfo = ClassTypeInfo.get("default.MyClass")

    // 获取实例成员变量信息
    let variableInfo = classInfo.getInstanceVariable("myVariable")

    // 获取类型信息
    let typeInfo = variableInfo.typeInfo
    println("变量类型: ${typeInfo.name}")

    return
}

运行结果：

变量类型: Int64

func findAllAnnotations<T>() where T <: Annotation

public func findAllAnnotations<T>(): Array<T> where T <: Annotation

功能：获取所有指定注解名称的自定义注解（通过泛型筛选）。

返回值：

Array<T> - 若无指定 T 类型的注解时，返回空数组；若有相关注解时，将所有该类型注解对象构成的数组返回。

示例：

import std.reflect.*

public class TestClassA {
    @CustomAnnotationA
    @CustomAnnotationB
    public var myVariable: Int64 = 42
}

main(): Unit {
    // 获取 TestClassA 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassA")

    // 获取实例成员变量信息
    let variableInfo = classInfo.getInstanceVariable("myVariable")

    // 查找所有 CustomAnnotationA 注解
    let annotationsA = variableInfo.findAllAnnotations<CustomAnnotationA>()
    println("CustomAnnotationA 注解数量: ${annotationsA.size}")

    // 查找所有 CustomAnnotationB 注解
    let annotationsB = variableInfo.findAllAnnotations<CustomAnnotationB>()
    println("CustomAnnotationB 注解数量: ${annotationsB.size}")

    return
}

@Annotation
public class CustomAnnotationA {
    public const init() {}
}

@Annotation
public class CustomAnnotationB {
    public const init() {}
}

运行结果：

CustomAnnotationA 注解数量: 1
CustomAnnotationB 注解数量: 1

func findAnnotation<T>() where T <: Annotation

public func findAnnotation<T>(): ?T where T <: Annotation

功能：尝试获取指定注解名称的自定义注解（通过泛型筛选）。

返回值：

?T - 如果成功匹配则返回该注解，重复标注或者无法匹配时返回 None。

示例：

import std.reflect.*

public class TestClassB {
    @AnnotationX
    public var myVariable: Int64 = 42
}

main(): Unit {
    // 获取 TestClassB 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassB")

    // 获取实例成员变量信息
    let variableInfo = classInfo.getInstanceVariable("myVariable")

    // 查找 AnnotationX 注解
    let annotationX = variableInfo.findAnnotation<AnnotationX>()

    match (annotationX) {
        case Some(_) => println("找到了 AnnotationX 注解")
        case None => println("未找到 AnnotationX 注解")
    }

    // 尝试查找不存在的注解
    let annotationY = variableInfo.findAnnotation<AnnotationY>()

    match (annotationY) {
        case Some(_) => println("找到了 AnnotationY 注解")
        case None => println("未找到 AnnotationY 注解")
    }

    return
}

@Annotation
public class AnnotationX {
    public const init() {}
}

@Annotation
public class AnnotationY {
    public const init() {}
}

运行结果：

找到了 AnnotationX 注解
未找到 AnnotationY 注解

func getAllAnnotations()

public func getAllAnnotations(): Array<Annotation>

功能：获取作用于该对象的所有自定义注解。

返回值：

Array<Annotation> - 作用于该对象的所有注解。

示例：

import std.reflect.*

public class TestClassC {
    @AnnotationX
    @AnnotationY
    public var myVariable: Int64 = 42
}

main(): Unit {
    // 获取 TestClassC 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassC")

    // 获取实例成员变量信息
    let variableInfo = classInfo.getInstanceVariable("myVariable")

    // 获取所有注解
    let allAnnotations = variableInfo.getAllAnnotations()
    println("注解总数: ${allAnnotations.size}")

    return
}

@Annotation
public class AnnotationX {
    public const init() {}
}

@Annotation
public class AnnotationY {
    public const init() {}
}

运行结果：

注解总数: 2

func getValue(Any)

public func getValue(instance: Any): Any

功能：获取该 InstanceVariableInfo 对应的实例成员变量在给定实例中的值。

参数：

instance: Any - 实例。

返回值：

Any - 该实例成员变量在入参实例中的值。

异常：

IllegalTypeException - 如果入参实例运行时类型与该实例成员变量信息所对应的实例成员变量所属的类型不严格相同，则抛出异常。

示例：

import std.reflect.*

public class TestClassGetValue {
    public var myVariable: Int64 = 42
    public let immutableVar: String = "Hello"
}

main(): Unit {
    // 创建实例
    let instance = TestClassGetValue()

    // 获取 TestClassGetValue 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassGetValue")

    // 获取实例成员变量信息
    let variableInfo = classInfo.getInstanceVariable("myVariable")
    let immutableVarInfo = classInfo.getInstanceVariable("immutableVar")

    // 获取变量值
    let value = variableInfo.getValue(instance) as Int64
    let immutableValue = immutableVarInfo.getValue(instance) as String

    println("myVariable 的值: ${value}")
    println("immutableVar 的值: ${immutableValue}")

    return
}

运行结果：

myVariable 的值: Some(42)
immutableVar 的值: Some(Hello)

func hashCode()

public func hashCode(): Int64

功能：获取该实例成员变量信息的哈希值。

返回值：

Int64 - 该实例成员变量信息的哈希值。

示例：

import std.reflect.*

public class TestClassD {
    public var myVariable: Int64 = 42
}

main(): Unit {
    // 获取 TestClassD 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassD")

    // 获取实例成员变量信息
    let variableInfo = classInfo.getInstanceVariable("myVariable")

    // 获取哈希值
    let hashCode = variableInfo.hashCode()
    println("哈希值: ${hashCode}")

    return
}

可能的运行结果：

哈希值: 94484935947016

func isMutable()

public func isMutable(): Bool

功能：判断该 InstanceVariableInfo 对应的实例成员变量是否可修改。

返回值：

Bool - 如果该实例成员变量信息所对应的实例成员变量可被修改则返回 true ，否则返回 false。

示例：

import std.reflect.*

public class TestClassE {
    public var mutableVariable: Int64 = 42
    public let immutableVariable: Int64 = 42
}

main(): Unit {
    // 获取 TestClassE 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassE")

    // 获取变量信息
    let mutableVar = classInfo.getInstanceVariable("mutableVariable")
    let immutableVar = classInfo.getInstanceVariable("immutableVariable")

    // 检查是否可修改
    let isMutable1 = mutableVar.isMutable()
    let isMutable2 = immutableVar.isMutable()

    println("mutableVariable 是否可修改: ${isMutable1}")
    println("immutableVariable 是否可修改: ${isMutable2}")

    return
}

运行结果：

mutableVariable 是否可修改: true
immutableVariable 是否可修改: false

func setValue(Any, Any)

public func setValue(instance: Any, newValue: Any): Unit

功能：设置该 InstanceVariableInfo 对应的实例成员变量在给定实例中的值。

参数：

instance: Any - 实例。
newValue: Any - 新值。

异常：

IllegalSetException - 如果该实例成员变量信息所对应的实例成员变量不可修改，则抛出异常。
IllegalTypeException - 如果入参实例运行时类型与该实例成员变量信息所对应的实例成员变量所属的类型不严格相同，则抛出异常。
IllegalTypeException - 如果新值 newValue 的运行时类型不是该实例成员变量信息所对应的实例成员变量的声明类型的子类型，则抛出异常。

示例：

import std.reflect.*

public class TestClassF {
    public var myVariable: Int64 = 42
}

main(): Unit {
    // 创建实例
    let instance = TestClassF()

    // 获取 TestClassF 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassF")

    // 获取实例成员变量信息
    let variableInfo = classInfo.getInstanceVariable("myVariable")

    // 设置新值
    variableInfo.setValue(instance, 100)

    // 验证值是否设置成功
    let currentValue = variableInfo.getValue(instance) as Int64
    println("当前值: ${currentValue}")

    return
}

运行结果：

当前值: Some(100)

func toString()

public func toString(): String

功能：获取字符串形式的该实例成员变量信息。

返回值：

String - 字符串形式的该实例成员变量信息。

示例：

import std.reflect.*

public class TestClassG {
    public var myVariable: Int64 = 42
}

main(): Unit {
    // 获取 TestClassG 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassG")

    // 获取实例成员变量信息
    let variableInfo = classInfo.getInstanceVariable("myVariable")

    // 获取字符串表示
    let str = variableInfo.toString()
    println("字符串表示: ${str}")

    return
}

运行结果：

字符串表示: myVariable: Int64

operator func !=(InstanceVariableInfo)

public operator func !=(other: InstanceVariableInfo): Bool

功能：判断该实例成员变量信息与给定的另一个实例成员变量信息是否不等。

参数：

other: InstanceVariableInfo - 被比较相等性的另一个实例成员变量信息。

返回值：

Bool - 如果该实例成员变量信息与另一个不等则返回 true，否则返回 false。

示例：

import std.reflect.*

public class TestClassH {
    public var variable1: Int64 = 42
    public var variable2: Int64 = 42
}

main(): Unit {
    // 获取 TestClassH 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassH")

    // 获取实例成员变量信息
    let var1 = classInfo.getInstanceVariable("variable1")
    let var2 = classInfo.getInstanceVariable("variable2")

    // 比较两个不同的变量信息
    let result1 = var1 != var2
    println("两个不同的变量信息不相等: ${result1}")

    // 比较相同的变量信息
    let result2 = var1 != var1
    println("相同的变量信息不相等: ${result2}")

    return
}

运行结果：

两个不同的变量信息不相等: true
相同的变量信息不相等: false

operator func ==(InstanceVariableInfo)

public operator func ==(other: InstanceVariableInfo): Bool

功能：判断该实例成员变量信息与给定的另一个实例成员变量信息是否相等。

参数：

other: InstanceVariableInfo - 被比较相等性的另一个实例成员变量信息。

返回值：

Bool - 如果该实例成员变量信息与另一个相等则返回 true，否则返回 false。

示例：

import std.reflect.*

public class TestClassI {
    public var variable1: Int64 = 42
    public var variable2: Int64 = 42
}

main(): Unit {
    // 获取 TestClassI 类型信息
    let classInfo = ClassTypeInfo.get("default.TestClassI")

    // 获取实例成员变量信息
    let var1 = classInfo.getInstanceVariable("variable1")
    let var2 = classInfo.getInstanceVariable("variable2")

    // 比较两个不同的变量信息
    let result1 = var1 == var2
    println("两个不同的变量信息相等: ${result1}")

    // 比较相同的变量信息
    let result2 = var1 == var1
    println("相同的变量信息相等: ${result2}")

    return
}

运行结果：

两个不同的变量信息相等: false
相同的变量信息相等: true

class InterfaceTypeInfo

public class InterfaceTypeInfo <: TypeInfo {}

功能：interface 类型的类型信息。

父类型：

TypeInfo

prop sealedSubtypes

public prop sealedSubtypes: Collection<TypeInfo>

功能：如果该 InterfaceTypeInfo 所对应的 interface 类型拥有 sealed 语义，则获取该 interface 类型所在包内的所有子类型的类型信息，返回对应集合。

类型：Collection<TypeInfo>

示例：

import std.reflect.*

// 创建一个sealed接口
sealed interface Shape {}

// 创建实现该接口的类
public class Circle <: Shape {
    public var radius: Int64 = 5
}

public class Square <: Shape {
    public var side: Int64 = 4
}

main(): Unit {
    // 获取接口类型信息
    let shapeType = InterfaceTypeInfo.get("default.Shape")

    // 获取sealed子类型信息
    let subtypes = shapeType.sealedSubtypes
    println("sealed子类型数量: ${subtypes.size}")

    // 遍历并打印所有sealed子类型
    for (subtype in subtypes) {
        println("子类型: ${subtype.name}")
    }

    return
}

运行结果：

sealed子类型数量: 3
子类型: Shape
子类型: Circle
子类型: Square

static func get(String)

public redef static func get(qualifiedName: String): InterfaceTypeInfo

功能：获取给定 qualifiedName 所对应的类型的 InterfaceTypeInfo。

参数：

qualifiedName: String - 类型的限定名称。

返回值：

InterfaceTypeInfo - 类型的限定名称 qualifiedName 所对应的 Interface 类型的类型信息。

异常：

InfoNotFoundException - 如果无法获取与给定类型的限定名称 qualifiedName 匹配的类型所对应的类型信息，则抛出异常。
IllegalTypeException - 如果获取到的类型信息不是 InterfaceTypeInfo，则抛出异常。

示例：

import std.reflect.*

public interface Rectangular {}

main(): Unit {
    let ty = InterfaceTypeInfo.get("default.Rectangular")
    println(ty)
    return
}

运行结果：

default.Rectangular

static func of(Any)

public redef static func of(a: Any): InterfaceTypeInfo

功能：获取给定的任意类型实例的运行时类型所对应的类型信息。

运行时类型是指在程序运行时，通过动态绑定确定的类型，运行时类型与实例对象相绑定。在继承等场景下运行时类型和静态类型可能不一致。

参数：

a: Any - 任意类型的实例。

返回值：

InterfaceTypeInfo - 实例 a 的运行时类型所对应的类型信息。

异常：

InfoNotFoundException - 如果无法获得实例 a 的运行时类型所对应的类型信息，则抛出异常。
IllegalTypeException - 如果获取到的类型信息不是 InterfaceTypeInfo，则抛出异常。

示例：

import std.reflect.*

public open class Drawable {}

public class Point <: Drawable {
    public var x: Int64 = 0
    public var y: Int64 = 0
}

main(): Unit {
    // 创建实例
    let point: Drawable = Point()

    // 获取实例的运行时类型信息
    let runtimeType = InterfaceTypeInfo.of(point)
    println("运行时类型: ${runtimeType.name}")

    return
}

运行结果：

运行时类型: Point

static func of<T>()

public redef static func of<T>(): InterfaceTypeInfo

功能：获取给定 T 类型对应的类型信息。

返回值：

InterfaceTypeInfo - T 类型对应的类型信息。

异常：

InfoNotFoundException - 如果无法获得类型 T 所对应的类型信息，抛出异常。
IllegalTypeException - 如果获取到的类型信息不是 InterfaceTypeInfo，则抛出异常。

示例：

import std.reflect.*

public interface Drawable {}

main(): Unit {
    // 通过泛型获取接口类型信息
    let drawableType = InterfaceTypeInfo.of<Drawable>()
    println("Drawable接口的类型信息: ${drawableType.name}")

    return
}

运行结果：

Drawable接口的类型信息: Drawable

func isSealed()

public func isSealed(): Bool

功能：判断该 InterfaceTypeInfo 所对应的 interface 类型是否拥有 sealed 语义。

返回值：

Bool - 如果该 interface 类型拥有 sealed 语义则返回 true，否则返回 false。

示例：

import std.reflect.*

// 创建一个sealed接口
sealed interface Shape {}

main(): Unit {
    // 获取接口类型信息
    let shapeType = InterfaceTypeInfo.get("default.Shape")

    // 检查是否为sealed接口
    let isSealed = shapeType.isSealed()
    println("Shape接口是否为sealed: ${isSealed}")

    return
}

运行结果：

Shape接口是否为sealed: true

class PackageInfo

public class PackageInfo <: Equatable<PackageInfo> & Hashable & ToString {}

功能：描述包信息。

父类型：

prop functions

public prop functions: Collection<GlobalFunctionInfo>

功能：获取该 PackageInfo 对应的包中所有 public 全局函数的信息所组成的列表。

类型：Collection<GlobalFunctionInfo>

示例：

package abc.test

import std.reflect.*

// 定义一些公共全局函数用于演示
public func testFunction1(): String {
    return "Hello from testFunction1"
}

public func testFunction2(x: Int64): Int64 {
    return x * 2
}

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("abc.test")

    // 获取包中的全局函数信息
    let functions = packageInfo.functions
    println("全局函数数量: ${functions.size}")

    return
}

运行结果：

全局函数数量: 2

prop name

public prop name: String

功能：获取该包信息所对应的包的名称。

类型：String

示例：

package abc.test

import std.reflect.*

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("abc.test")

    // 获取包名称
    let name = packageInfo.name
    println("包名称: ${name}")

    return
}

运行结果：

包名称: test

prop organizationName

public prop organizationName: String

功能：获取该包信息所对应的包的组织名称。

类型：String

示例：

package abc.test

import std.reflect.*

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("abc.test")

    // 获取包的组织名称
    let orgName = packageInfo.organizationName
    println("组织名称: '${orgName}'")

    return
}

运行结果：

组织名称: ''

prop parentPackage

public prop parentPackage: PackageInfo

功能：获取该 PackageInfo 对应的父包的 PackageInfo。

类型：PackageInfo

示例：

import std.reflect.*

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("default")

    // 获取父包信息
    let parentPackage = packageInfo.parentPackage
    println("父包名称: ${parentPackage.name}")

    return
}

运行结果：

父包名称: default

异常：

InfoNotFoundException - 如果父包未被加载，则会抛出异常。

prop qualifiedName

public prop qualifiedName: String

功能：获取该 PackageInfo 对应的包的限定名称。

类型：String

示例：

package abc.test

import std.reflect.*

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("abc.test")

    // 获取包限定名称
    let qualifiedName = packageInfo.qualifiedName
    println("包限定名称: ${qualifiedName}")

    return
}

运行结果：

包限定名称: abc.test

prop rootPackage

public prop rootPackage: PackageInfo

功能：获取该 PackageInfo 对应的 root 包的 PackageInfo。

类型：PackageInfo

示例：

import std.reflect.*

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("default")

    // 获取根包信息
    let rootPackage = packageInfo.rootPackage
    println("根包名称: ${rootPackage.name}")

    return
}

运行结果：

根包名称: default

异常：

InfoNotFoundException - 如果 root 包未被加载，则会抛出异常。

prop subPackages

public prop subPackages: Collection<PackageInfo>

功能：获取该 PackageInfo 对应的所有子包的 PackageInfo 集合。

类型：Collection<PackageInfo>

示例：

import std.reflect.*

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("default")

    // 获取子包信息
    let subPackages = packageInfo.subPackages
    println("子包数量: ${subPackages.size}")

    return
}

运行结果：

子包数量: 0

prop typeInfos

public prop typeInfos: Collection<TypeInfo>

功能：获取该 PackageInfo 对应的包中所有全局定义的 public 类型的类型信息，返回对应集合。

类型：Collection<TypeInfo>

示例：

package abc.test

import std.reflect.*

public class A {}

public interface B {}

public struct C {}

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("abc.test")

    // 获取类型信息
    let typeInfos = packageInfo.typeInfos
    println("类型数量: ${typeInfos.size}")

    return
}

运行结果：

类型数量: 3

prop variables

public prop variables: Collection<GlobalVariableInfo>

功能：获取该 PackageInfo 对应的包中所有 public 全局变量的信息所组成的列表。

类型：Collection<GlobalVariableInfo>

示例：

package abc.test

import std.reflect.*

// 定义一些公共全局变量用于演示
public var testVariable1: Int64 = 42
public var testVariable2: String = "Hello"

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("abc.test")

    // 获取包中的全局变量信息
    let variables = packageInfo.variables
    println("全局变量数量: ${variables.size}")

    return
}

运行结果：

全局变量数量: 2

prop version

public prop version: String

功能：获取该 PackageInfo 对应的包的版本号。

类型：String

示例：

import std.reflect.*

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("default")

    // 获取版本信息
    let version = packageInfo.version
    println("版本: '${version}'")

    return
}

运行结果：

版本: ''

static func get(String)

public static func get(qualifiedName: String): PackageInfo

功能：获取给定 qualifiedName 所对应的 PackageInfo。

参数：

qualifiedName: String - 类型的限定名称。

返回值：

PackageInfo - 类型的限定名称 qualifiedName 所对应的包信息。

异常：

InfoNotFoundException - 如果无法获取与给定类型的限定名称 qualifiedName 所对应的类型信息，则抛出异常。

示例：

package abc.test

import std.reflect.*

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("abc.test")
    println("包名称: ${packageInfo.name}")
    println("包限定名称: ${packageInfo.qualifiedName}")

    return
}

运行结果：

包名称: test
包限定名称: abc.test

static func load(String)

public static func load(path: String): PackageInfo

功能：运行时动态加载指定路径下的一个仓颉动态库模块并获得该模块的信息。

参数：

path: String - 共享库文件的绝对路径或相对路径。

返回值：

PackageInfo - 指定仓颉动态库的包信息。

异常：

ReflectException - 如果共享库加载失败，则会抛出异常。
ReflectException - 如果具有相同包名称或相同文件名的共享库被重复加载，则会抛出异常。
ReflectException - 如果动态库内部存在多个 Package，则抛出异常。
IllegalArgumentException - 当路径不合法时，抛出异常。

示例：

import std.reflect.*

main(): Unit {
    // 注意：load方法需要一个有效的动态库路径
    try {
        let packageInfo = PackageInfo.load("/path/to/library")
        println("加载的包名称: ${packageInfo.name}")
    } catch (e: IllegalArgumentException) {
        println("加载失败: ${e.message}")
    }

    println("这里仅展示使用方法")
    return
}

运行结果：

加载失败: Failed to load `/path/to/library` because of illegal path.
这里仅展示使用方法

func getFunction(String, Array<TypeInfo>)

public func getFunction(name: String, parameterTypes: Array<TypeInfo>): GlobalFunctionInfo

功能：尝试在该 PackageInfo 对应的包中获取拥有给定函数名称且与给定形参类型信息列表匹配的 public 全局函数的信息。

参数：

name: String - 全局函数的名称。
parameterTypes: Array<TypeInfo> - 形参类型信息列表。

返回值：

GlobalFunctionInfo - 如果成功匹配则返回该全局定义的 public 类型的函数信息。

异常：

InfoNotFoundException - 如果没找到对应全局定义的 public 全局函数，则抛出异常。

示例：

package abc.test

import std.reflect.*

public func addNumbers(a: Int64, b: Int64): Int64 {
    return a + b
}

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("abc.test")

    let intType: TypeInfo = PrimitiveTypeInfo.get("Int64")
    let paramTypes = [intType, intType]
    let functionInfo = packageInfo.getFunction("addNumbers", paramTypes)
    println("函数: ${functionInfo}")

    return
}

运行结果：

函数: func addNumbers(Int64, Int64): Int64

func getFunctions(String)

public func getFunctions(name: String): Array<GlobalFunctionInfo>

功能：尝试在该 PackageInfo 对应的包中获取拥有给定函数名称的所有 public 全局函数的信息。

参数：

name: String - 全局函数的名称。

返回值：

Array<GlobalFunctionInfo> - 拥有给定函数名称的所有 public 全局函数的信息数组。

示例：

package abc.test

import std.reflect.*

// 定义一些同名但参数不同的函数用于演示
public func process(x: Int64): Int64 {
    return x * 2
}

public func process(x: String): String {
    return "Processed: ${x}"
}

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("abc.test")

    // 获取所有名为process的函数
    let functions = packageInfo.getFunctions("process")
    println("名为process的函数数量: ${functions.size}")

    return
}

运行结果：

名为process的函数数量: 2

func getSubPackage(String)

public func getSubPackage(qualifiedName: String): PackageInfo

功能：尝试获取该 PackageInfo 对应限定名称为 qualifiedName 的子包的信息。

参数：

qualifiedName: String - 子包的限定名称。

返回值：

PackageInfo - 该子包的包信息。

异常：

InfoNotFoundException - 如果该子包不存在或者未加载，则会抛出异常。
IllegalArgumentException - 如果 qualifiedName 不符合规范，则抛出异常。

示例：

package abc.parent

import std.reflect.*

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("abc.parent")

    // 尝试获取子包（这里会抛出异常，因为我们没有创建子包）
    try {
        let subPackage = packageInfo.getSubPackage("child")
        println("子包名称: ${subPackage.name}")
    } catch (e: InfoNotFoundException) {
        println("子包未找到")
    }

    return
}

运行结果：

子包未找到

func getTypeInfo(String)

public func getTypeInfo(qualifiedTypeName: String): TypeInfo

功能：尝试在该 PackageInfo 对应的包中获取拥有给定类型名称的全局定义的 public 类型的类型信息。

参数：

qualifiedTypeName: String - 类型的限定名称

返回值：

TypeInfo - 如果成功匹配则返回该全局定义的 public 类型的类型信息。

异常：

InfoNotFoundException - 如果没找到对应全局定义的 public 类型，则抛出异常。

示例：

package abc.test

import std.reflect.*

// 定义一个类用于演示
public class TestClass {
    public var value: Int64 = 0
}

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("abc.test")

    // 获取类型信息
    let typeInfo = packageInfo.getTypeInfo("abc.test.TestClass")
    println("类型名称: ${typeInfo.name}")

    return
}

运行结果：

类型名称: TestClass

func getVariable(String)

public func getVariable(name: String): GlobalVariableInfo

功能：尝试在该 PackageInfo 对应的包中获取拥有给定变量名称的 public 全局变量的信息。

参数：

name: String - 全局变量的名称。

返回值：

GlobalVariableInfo - 如果成功匹配则返回该全局定义的 public 类型的变量信息。

异常：

InfoNotFoundException - 如果没找到对应全局定义的 public 全局变量，则抛出异常。

示例：

package abc.test

import std.reflect.*

// 定义一些公共全局变量用于演示
public var testVariable: Int64 = 42

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("abc.test")

    // 获取特定变量的信息
    let variableInfo = packageInfo.getVariable("testVariable")
    println("变量名称: ${variableInfo.name}")

    return
}

运行结果：

变量名称: testVariable

func hashCode()

public func hashCode(): Int64

功能：获取该包信息的哈希值。

返回值：

Int64 - 该包信息的哈希值。

示例：

import std.reflect.*

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("default")

    // 获取包信息的哈希值
    let hashCode = packageInfo.hashCode()
    println("包信息的哈希值: ${hashCode}")

    return
}

可能的运行结果：

包信息的哈希值: 94165683034880

func toString()

public func toString(): String

功能：获取字符串形式的该包信息。

返回值：

String - 字符串形式的该包信息。

示例：

import std.reflect.*

main(): Unit {
    // 获取当前包的信息
    let packageInfo = PackageInfo.get("default")

    // 获取包信息的字符串表示
    let str = packageInfo.toString()
    println("包信息的字符串表示: ${str}")

    return
}

运行结果：

包信息的字符串表示: default

operator func !=(PackageInfo)

public operator func !=(other: PackageInfo): Bool

功能：判断该包信息与给定的另一个包信息是否不等。

参数：

other: PackageInfo - 被比较相等性的另一个包信息。

返回值：

Bool - 如果该包信息与另一个不等则返回 true，否则返回 false。

示例：

import std.reflect.*

main(): Unit {
    // 获取当前包的信息
    let packageInfo1 = PackageInfo.get("default")
    let packageInfo2 = PackageInfo.get("default")

    // 比较两个包信息是否不等
    let result = packageInfo1 != packageInfo2
    println("两个包信息不等: ${result}")

    return
}

运行结果：

两个包信息不等: false

operator func ==(PackageInfo)

public operator func ==(other: PackageInfo): Bool

功能：判断该包信息与给定的另一个包信息是否相等。

参数：

other: PackageInfo - 被比较相等性的另一个包信息。

返回值：

Bool - 如果该包信息与另一个相等则返回 true，否则返回 false。

示例：

import std.reflect.*

main(): Unit {
    // 获取当前包的信息
    let packageInfo1 = PackageInfo.get("default")
    let packageInfo2 = PackageInfo.get("default")

    // 比较两个包信息是否相等
    let result = packageInfo1 == packageInfo2
    println("两个包信息相等: ${result}")

    return
}

运行结果：

两个包信息相等: true

class ParameterInfo

public class ParameterInfo <: Equatable<ParameterInfo> & Hashable & ToString {}

功能：描述函数形参信息。

父类型：

prop annotations

public prop annotations: Collection<Annotation>

功能：获取所有作用于该 ParameterInfo 对应的函数形参的自定义注解，返回对应集合。

类型：Collection<Annotation>

示例：

import std.reflect.*

// 定义一个注解用于演示
@Annotation
public class MyAnnotation {
    public const init() {}
}

// 定义一个带注解的函数用于演示
public func testFunction(@MyAnnotation param: Int64): Int64 {
    return param * 2
}

main(): Unit {
    // 获取函数信息
    let packageInfo = PackageInfo.get("default")
    let functions = packageInfo.getFunctions("testFunction")

    if (functions.size > 0) {
        let functionInfo = functions[0]
        let parameters = functionInfo.parameters

        if (parameters.size > 0) {
            let paramInfo = parameters[0]
            let annotations = paramInfo.annotations
            println("参数注解数量: ${annotations.size}")
        }
    }

    return
}

运行结果：

参数注解数量: 1

prop index

public prop index: Int64

功能：获知该 ParameterInfo 对应的形参是其所在函数的第几个形参。

类型：Int64

示例：

import std.reflect.*

// 定义一个带多个参数的函数用于演示
public func testFunction(first: Int64, second: String, third: Bool): Int64 {
    return first
}

main(): Unit {
    // 获取函数信息
    let packageInfo = PackageInfo.get("default")
    let functions = packageInfo.getFunctions("testFunction")

    if (functions.size > 0) {
        let functionInfo = functions[0]
        let parameters = functionInfo.parameters

        for (param in parameters) {
            println("参数名称: ${param.name}, 索引: ${param.index}")
        }
    }

    return
}

运行结果：

参数名称: first, 索引: 0
参数名称: second, 索引: 1
参数名称: third, 索引: 2

prop name

public prop name: String

功能：获取该 ParameterInfo 对应的形参的名称。

类型：String

示例：

import std.reflect.*

// 定义一个带参数的函数用于演示
public func calculateSum(x: Int64, y: Int64): Int64 {
    return x + y
}

main(): Unit {
    // 获取函数信息
    let packageInfo = PackageInfo.get("default")
    let functions = packageInfo.getFunctions("calculateSum")

    if (functions.size > 0) {
        let functionInfo = functions[0]
        let parameters = functionInfo.parameters

        for (param in parameters) {
            println("参数名称: ${param.name}")
        }
    }

    return
}

运行结果：

参数名称: x
参数名称: y

prop typeInfo

public prop typeInfo: TypeInfo

功能：获取该 ParameterInfo 对应的函数形参的声明类型所对应的类型信息。

类型：TypeInfo

示例：

import std.reflect.*

// 定义一个带不同类型的参数的函数用于演示
public func processData(count: Int64, name: String, isActive: Bool): Int64 {
    return count
}

main(): Unit {
    // 获取函数信息
    let packageInfo = PackageInfo.get("default")
    let functions = packageInfo.getFunctions("processData")

    if (functions.size > 0) {
        let functionInfo = functions[0]
        let parameters = functionInfo.parameters

        for (param in parameters) {
            println("参数名称: ${param.name}, 类型: ${param.typeInfo.name}")
        }
    }

    return
}

运行结果：

参数名称: count, 类型: Int64
参数名称: name, 类型: String
参数名称: isActive, 类型: Bool

func findAllAnnotations<T>() where T <: Annotation

public func findAllAnnotations<T>(): Array<T> where T <: Annotation

功能：获取所有指定注解名称的自定义注解（通过泛型筛选）。

返回值：

Array<T> - 若无指定 T 类型的注解时，返回空数组；若有相关注解时，将所有该类型注解对象构成的数组返回。

示例：

import std.reflect.*

// 定义注解用于演示
@Annotation
public class FirstAnnotation {
    public const init() {}
}

@Annotation
public class SecondAnnotation {
    public const init() {}
}

// 定义一个带多个注解的函数参数用于演示
public func testFunction(
    @FirstAnnotation
    @SecondAnnotation
    value: Int64
): Int64 {
    return value
}

main(): Unit {
    // 获取函数信息
    let packageInfo = PackageInfo.get("default")
    let functions = packageInfo.getFunctions("testFunction")

    if (functions.size > 0) {
        let functionInfo = functions[0]
        let parameters = functionInfo.parameters

        if (parameters.size > 0) {
            let paramInfo = parameters[0]
            let firstAnnotations = paramInfo.findAllAnnotations<FirstAnnotation>()
            let secondAnnotations = paramInfo.findAllAnnotations<SecondAnnotation>()

            println("FirstAnnotation注解数量: ${firstAnnotations.size}")
            println("SecondAnnotation注解数量: ${secondAnnotations.size}")
        }
    }

    return
}

运行结果：

FirstAnnotation注解数量: 1
SecondAnnotation注解数量: 1

func findAnnotation<T>() where T <: Annotation

public func findAnnotation<T>(): ?T where T <: Annotation

功能：尝试获取指定注解名称的自定义注解（通过泛型筛选）。

返回值：

?T - 如果成功匹配则返回该注解，重复标注或者无法匹配时返回 None。

示例：

import std.reflect.*

// 定义注解用于演示
@Annotation
public class MyAnnotation {
    public const init() {}
}

// 定义一个带注解的函数参数用于演示
public func testFunction(@MyAnnotation value: Int64): Int64 {
    return value
}

main(): Unit {
    // 获取函数信息
    let packageInfo = PackageInfo.get("default")
    let functions = packageInfo.getFunctions("testFunction")

    if (functions.size > 0) {
        let functionInfo = functions[0]
        let parameters = functionInfo.parameters

        if (parameters.size > 0) {
            let paramInfo = parameters[0]
            let annotation = paramInfo.findAnnotation<MyAnnotation>()

            match (annotation) {
                case Some(_) => println("找到了MyAnnotation注解")
                case None => println("未找到MyAnnotation注解")
            }
        }
    }

    return
}

运行结果：

找到了MyAnnotation注解

func getAllAnnotations()

public func getAllAnnotations(): Array<Annotation>

功能：获取作用于该对象的所有自定义注解。

返回值：

Array<Annotation> - 作用于该对象的所有注解。

示例：

import std.reflect.*

// 定义注解用于演示
@Annotation
public class FirstAnnotation {
    public const init() {}
}

@Annotation
public class SecondAnnotation {
    public const init() {}
}

// 定义一个带多个注解的函数参数用于演示
public func testFunction(
    @FirstAnnotation
    @SecondAnnotation
    value: Int64
): Int64 {
    return value
}

main(): Unit {
    // 获取函数信息
    let packageInfo = PackageInfo.get("default")
    let functions = packageInfo.getFunctions("testFunction")

    if (functions.size > 0) {
        let functionInfo = functions[0]
        let parameters = functionInfo.parameters

        if (parameters.size > 0) {
            let paramInfo = parameters[0]
            let allAnnotations = paramInfo.getAllAnnotations()

            println("总注解数量: ${allAnnotations.size}")
            println("成功获取所有注解")
        }
    }

    return
}

运行结果：

总注解数量: 2
成功获取所有注解

func hashCode()

public func hashCode(): Int64

功能：获取该函数形参信息的哈希值。

返回值：

Int64 - 该函数形参信息的哈希值。

示例：

import std.reflect.*

// 定义一个函数用于演示
public func calculate(x: Int64): Int64 {
    return x * 2
}

main(): Unit {
    // 获取函数信息
    let packageInfo = PackageInfo.get("default")
    let functions = packageInfo.getFunctions("calculate")

    if (functions.size > 0) {
        let functionInfo = functions[0]
        let parameters = functionInfo.parameters

        if (parameters.size > 0) {
            let paramInfo = parameters[0]
            let hashCode = paramInfo.hashCode()

            println("参数信息的哈希值: ${hashCode}")
        }
    }

    return
}

可能的运行结果：

参数信息的哈希值: 93836504484944

func toString()

public func toString(): String

功能：获取字符串形式的该函数形参信息。

返回值：

String - 字符串形式的该函数形参信息。

示例：

import std.reflect.*

// 定义一个函数用于演示
public func calculate(x: Int64): Int64 {
    return x * 2
}

main(): Unit {
    // 获取函数信息
    let packageInfo = PackageInfo.get("default")
    let functions = packageInfo.getFunctions("calculate")

    if (functions.size > 0) {
        let functionInfo = functions[0]
        let parameters = functionInfo.parameters

        if (parameters.size > 0) {
            let paramInfo = parameters[0]
            let str = paramInfo.toString()

            println("参数信息的字符串表示: ${str}")
        }
    }

    return
}

运行结果：

参数信息的字符串表示: Int64

operator func !=(ParameterInfo)

public operator func !=(other: ParameterInfo): Bool

功能：判断该函数形参信息与给定的另一个函数形参信息是否不等。

参数：

other: ParameterInfo - 被比较相等性的另一个函数形参信息。

返回值：

Bool - 如果该函数形参信息与另一个不等则返回 true，否则返回 false。

示例：

import std.reflect.*

// 定义一个函数用于演示
public func calculate(x: Int64, y: Int64): Int64 {
    return x + y
}

main(): Unit {
    // 获取函数信息
    let packageInfo = PackageInfo.get("default")
    let functions = packageInfo.getFunctions("calculate")

    if (functions.size > 0) {
        let functionInfo = functions[0]
        let parameters = functionInfo.parameters

        if (parameters.size >= 2) {
            let param1 = parameters[0]
            let param2 = parameters[1]
            let result = param1 != param2

            println("两个参数不等: ${result}")
        }
    }

    return
}

运行结果：

两个参数不等: true

operator func ==(ParameterInfo)

public operator func ==(other: ParameterInfo): Bool

功能：判断该函数形参信息与给定的另一个函数形参信息是否相等。

参数：

other: ParameterInfo - 被比较相等性的另一个函数形参信息。

返回值：

Bool - 如果该函数形参信息与另一个相等则返回 true，否则返回 false。

示例：

import std.reflect.*

// 定义一个函数用于演示
public func calculate(x: Int64): Int64 {
    return x * 2
}

main(): Unit {
    // 获取函数信息
    let packageInfo = PackageInfo.get("default")
    let functions = packageInfo.getFunctions("calculate")

    if (functions.size > 0) {
        let functionInfo = functions[0]
        let parameters = functionInfo.parameters

        if (parameters.size > 0) {
            let param1 = parameters[0]
            let param2 = parameters[0]
            let result = param1 == param2

            println("两个参数相等: ${result}")
        }
    }

    return
}

运行结果：

两个参数相等: true

class PrimitiveTypeInfo

public class PrimitiveTypeInfo <: TypeInfo {}

功能：描述原始数据类型的类型信息。

原始数据类型包括无类型（Nothing）、单元类型（Unit）、字符类型（Rune）、布尔类型（Bool），整形类型（Int8，Int16，Int32，Int64，IntNative，UInt8，UInt16，UInt32，UInt64，UIntNative）和浮点类型（Float16，Float32，Float64）。

父类型：

TypeInfo

static func get(String)

public static redef func get(qualifiedName: String): PrimitiveTypeInfo

功能：获取给定的类型的限定名称所对应类型的 PrimitiveTypeInfo。

参数：

qualifiedName: String - 类型的限定名称。

返回值：

PrimitiveTypeInfo - 类型的限定名称 qualifiedName 所对应的类型的类型信息。

异常：

InfoNotFoundException - 如果无法获取与给定类型的限定名称 qualifiedName 匹配的类型所对应的类型信息，则抛出异常。
IllegalTypeException - 如果获取到的类型信息不是 PrimitiveTypeInfo，则抛出异常。

示例：

import std.reflect.*

main(): Unit {
    var pti = PrimitiveTypeInfo.get("Int64")
    println(pti)
    return
}

运行结果：

Int64

static func of(Any)

public static redef func of(a: Any): PrimitiveTypeInfo

功能：获取给定的任意类型实例的运行时类型所对应的类型信息。

运行时类型是指在程序运行时，通过动态绑定确定的类型，运行时类型与实例对象相绑定。在继承等场景下运行时类型和静态类型可能不一致。

参数：

a: Any - 任意类型的实例。

返回值：

PrimitiveTypeInfo - 实例 a 的运行时类型所对应的类型信息。

异常：

InfoNotFoundException - 如果无法获得实例 a 的运行时类型所对应的类型信息，则抛出异常。
IllegalTypeException - 如果获取到的类型信息不是 PrimitiveTypeInfo，则抛出异常。

示例：

import std.reflect.*

main(): Unit {
    var a = 10
    var pti = PrimitiveTypeInfo.of(a)
    println(pti)
    return
}

运行结果：

Int64

static func of<T>()

public static redef func of<T>(): PrimitiveTypeInfo

功能：获取给定 T 类型对应的类型信息。

返回值：

PrimitiveTypeInfo - T 类型对应的类型信息。

异常：

InfoNotFoundException - 如果无法获得类型 T 所对应的类型信息，抛出异常。
IllegalTypeException - 如果获取到的类型信息不是 PrimitiveTypeInfo，则抛出异常。

示例：

import std.reflect.*

main(): Unit {
    var pti = PrimitiveTypeInfo.of<Int64>()
    println(pti)
    return
}

运行结果：

Int64

class StaticFunctionInfo

public class StaticFunctionInfo <: Equatable<StaticFunctionInfo> & Hashable & ToString {}

功能：描述静态成员函数信息。

父类型：

prop annotations

public prop annotations: Collection<Annotation>

功能：获取所有作用于该 StaticFunctionInfo 对应的静态成员函数的自定义注解，返回对应集合。

类型：Collection<Annotation>

示例：

package test

import std.reflect.*

// 定义一个注解用于演示
@Annotation
public class MyAnnotation {
    public const init() {}
}

// 定义一个带注解的类和静态函数用于演示
public class TestClass {
    @MyAnnotation
    public static func testFunction(): String {
        return "Hello from test function"
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态函数信息
    let staticFunctions = classInfo.staticFunctions
    for (staticFunction in staticFunctions) {
        let annotations = staticFunction.annotations
        println("静态函数注解数量: ${annotations.size}")
    }

    return
}

运行结果：

静态函数注解数量: 1

prop genericParams

public prop genericParams: Collection<GenericTypeInfo>

功能：获取该 StaticFunctionInfo 对应的实例成员函数的泛型参数信息列表。

类型：Collection<GenericTypeInfo>

异常：

InfoNotFoundException - GlobalFunctionInfo 没有泛型参数时抛出异常。

示例：

package test

import std.reflect.*

// 定义一个带泛型参数的类和静态函数用于演示
public class TestClass {
    public static func genericFunction<T>(value: T): T {
        return value
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态函数信息
    let staticFunctions = classInfo.staticFunctions
    for (staticFunction in staticFunctions) {
        if (staticFunction.name == "genericFunction") {
            try {
                let genericParams = staticFunction.genericParams
                println("泛型参数数量: ${genericParams.size}")
            } catch (e: InfoNotFoundException) {
                println("该函数没有泛型参数")
            }
            break
        }
    }

    return
}

运行结果：

泛型参数数量: 1

prop modifiers

public prop modifiers: Collection<ModifierInfo>

功能：获取该 StaticFunctionInfo 对应的静态成员函数所拥有的所有修饰符的信息，返回对应集合。

类型：Collection<ModifierInfo>

示例：

package test

import std.reflect.*

// 定义一个带修饰符的类和静态函数用于演示
public class TestClass {
    public static func publicFunction(): String {
        return "This is a public function"
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态函数信息
    let staticFunctions = classInfo.staticFunctions
    for (staticFunction in staticFunctions) {
        if (staticFunction.name == "publicFunction") {
            let modifiers = staticFunction.modifiers
            println("函数修饰符数量: ${modifiers.size}")
            break
        }
    }

    return
}

运行结果：

函数修饰符数量: 1

prop name

public prop name: String

功能：获取该 StaticFunctionInfo 对应的静态成员函数的名称。

类型：String

示例：

package test

import std.reflect.*

// 定义一个类和静态函数用于演示
public class TestClass {
    public static func calculateSum(x: Int64, y: Int64): Int64 {
        return x + y
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态函数信息
    let staticFunctions = classInfo.staticFunctions
    for (staticFunction in staticFunctions) {
        println("静态函数名称: ${staticFunction.name}")
    }

    return
}

运行结果：

静态函数名称: calculateSum

prop parameters

public prop parameters: ReadOnlyList<ParameterInfo>

功能：获取该 StaticFunctionInfo 对应的静态成员函数的参数信息列表。

类型：ReadOnlyList<ParameterInfo>

示例：

package test

import std.reflect.*

// 定义一个带参数的类和静态函数用于演示
public class TestClass {
    public static func processData(name: String, age: Int64): String {
        return "Name: ${name}, Age: ${age}"
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态函数信息
    let staticFunctions = classInfo.staticFunctions
    for (staticFunction in staticFunctions) {
        if (staticFunction.name == "processData") {
            let parameters = staticFunction.parameters
            println("参数数量: ${parameters.size}")

            for (param in parameters) {
                println("参数名称: ${param.name}, 类型: ${param.typeInfo.name}")
            }
            break
        }
    }

    return
}

运行结果：

参数数量: 2
参数名称: name, 类型: String
参数名称: age, 类型: Int64

prop returnType

public prop returnType: TypeInfo

功能：获取该 StaticFunctionInfo 对应的静态成员函数的返回值类型的类型信息。

类型：TypeInfo

示例：

package test

import std.reflect.*

// 定义一个带返回类型的类和静态函数用于演示
public class TestClass {
    public static func getString(): String {
        return "Hello"
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态函数信息
    let staticFunctions = classInfo.staticFunctions
    for (staticFunction in staticFunctions) {
        if (staticFunction.name == "getString") {
            let returnType = staticFunction.returnType
            println("返回类型: ${returnType.name}")
            break
        }
    }

    return
}

运行结果：

返回类型: String

func apply(TypeInfo, Array<Any>)

public func apply(thisType: TypeInfo, args: Array<Any>): Any

功能：调用该 StaticFunctionInfo 对应静态成员函数，传入方法所属的类型信息和实参列表并返回调用结果。

参数：

thisType: TypeInfo - 该方法所属的类。
args: Array<Any> - 实参列表。

返回值：

Any - 该静态成员函数的调用结果。

异常：

InvocationTargetException - 如果该函数信息对应的静态成员函数存在泛型参数，则会抛出异常。
InfoNotFoundException - 如果该函数信息对应的静态成员函数的函数体未实现，则会抛出异常。
IllegalArgumentException - 如果实参列表中的实参的数目与该静态成员函数信息所对应的静态成员函数的形参列表中的形参的数目不等，则抛出异常。
IllegalArgumentException - 如果 thisType 和该静态函数的函数签名不一致，则抛出异常。
IllegalTypeException - 如果实参列表中的任何一个实参的运行时类型不是该静态成员函数信息所对应的静态成员函数的对应形参的声明类型的子类型，则抛出异常。
Exception - 如果被调用的静态成员函数信息所对应的静态成员函数内部抛出异常，则该异常将被封装为 Exception 异常并抛出。

示例：

package test

import std.reflect.*

public class Rectangular {
    public static func myName(): String {
        "my name is Rectangular"
    }
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 ClassTypeInfo，也可以通过实例获取 ClassTypeInfo
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 获取静态函数
    let sf = ty.getStaticFunction("myName")

    let result = sf.apply(ty) as String
    println(result)
    return
}

运行结果：

Some(my name is Rectangular)

func apply(TypeInfo, Array<TypeInfo>, Array<Any>)

public func apply(thisType: TypeInfo, genericTypeArgs: Array<TypeInfo>, args: Array<Any>): Any

功能：调用该 StaticFunctionInfo 对应静态成员函数，传入方法所属的类型信息和实参列表并返回调用结果。

参数：

thisType: TypeInfo - 该方法所属的类。
genericTypeArgs: Array<TypeInfo> - 泛型参数类型列表。
args: Array<Any> - 实参列表。

返回值：

Any - 该静态成员函数的调用结果。

异常：

InvocationTargetException - 如果该函数信息对应的静态成员函数是非泛型函数，则抛出异常。
InfoNotFoundException - 如果该函数信息对应的静态成员函数的函数体未实现，则会抛出异常。
IllegalArgumentException - 如果实参列表中的实参的数目与该静态成员函数信息所对应的静态成员函数的形参列表中的形参的数目不等，则抛出异常。
IllegalArgumentException - 如果实参列表中的泛型参数的数目与该静态成员函数信息所对应的泛型参数的数目不等，则抛出异常。
IllegalArgumentException - 如果 thisType 和该静态函数的函数签名不一致，则抛出异常。
IllegalTypeException - 如果实参列表中的任何一个实参的运行时类型不是该静态成员函数信息所对应的静态成员函数的对应形参的声明类型的子类型，则抛出异常。
IllegalTypeException - 如果传入的实参列表和泛型参数类型列表 genericTypeArgs 不满足该静态成员函数信息所对应的静态成员函数的参数的类型约束，则抛出异常。
Exception - 如果被调用的静态成员函数信息所对应的静态成员函数内部抛出异常，则该异常将被封装为 Exception 异常并抛出。

示例：

package test

import std.reflect.*

public class GenericClass {
    public static func process<T>(value: T): T {
        return value
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.GenericClass")

    // 获取静态函数信息
    let staticFunctions = classInfo.staticFunctions
    var staticFunction: ?StaticFunctionInfo = None

    for (sf in staticFunctions) {
        if (sf.name == "process") {
            staticFunction = sf
            break
        }
    }

    // 准备参数
    let stringTypeInfo = TypeInfo.get("std.core.String")

    // 调用带有泛型参数的函数
    try {
        let genericClass = GenericClass()
        let sf = staticFunction.getOrThrow()
        let result = sf.apply(classInfo, [stringTypeInfo], ["Hello World"]) as String
        println("调用结果: ${result}")
    } catch (e: Exception) {
        println("调用失败: ${e.message}")
    }

    return
}

运行结果：

调用结果: Some(Hello World)

func findAllAnnotations<T>() where T <: Annotation

public func findAllAnnotations<T>(): Array<T> where T <: Annotation

功能：获取所有指定注解名称的自定义注解（通过泛型筛选）。

返回值：

Array<T> - 若无指定 T 类型的注解时，返回空数组；若有相关注解时，将所有该类型注解对象构成的数组返回。

示例：

package test

import std.reflect.*

// 定义一个注解用于演示
@Annotation
public class MyAnnotation {
    public const init() {}
}

// 定义另一个注解用于演示
@Annotation
public class AnotherAnnotation {
    public const init() {}
}

// 定义一个带注解的类和静态函数用于演示
public class TestClass {
    @MyAnnotation
    @AnotherAnnotation
    public static func annotatedFunction(): String {
        return "This function has annotations"
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态函数信息
    let staticFunctions = classInfo.staticFunctions
    for (staticFunction in staticFunctions) {
        if (staticFunction.name == "annotatedFunction") {
            let myAnnotations = staticFunction.findAllAnnotations<MyAnnotation>()
            println("MyAnnotation注解数量: ${myAnnotations.size}")
            break
        }
    }

    return
}

运行结果：

MyAnnotation注解数量: 1

func findAnnotation<T>() where T <: Annotation

public func findAnnotation<T>(): ?T where T <: Annotation

功能：尝试获取指定注解名称的自定义注解（通过泛型筛选）。

返回值：

?T - 如果成功匹配则返回该注解，重复标注或者无法匹配时返回 None。

示例：

package test

import std.reflect.*

// 定义一个注解用于演示
@Annotation
public class MyAnnotation {
    public const init() {}
}

// 定义一个带注解的类和静态函数用于演示
public class TestClass {
    @MyAnnotation
    public static func annotatedFunction(): String {
        return "This function has annotations"
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态函数信息
    let staticFunctions = classInfo.staticFunctions
    for (staticFunction in staticFunctions) {
        if (staticFunction.name == "annotatedFunction") {
            let annotation = staticFunction.findAnnotation<MyAnnotation>()
            if (annotation.isSome()) {
                println("找到了MyAnnotation注解")
            } else {
                println("未找到MyAnnotation注解")
            }
            break
        }
    }

    return
}

运行结果：

找到了MyAnnotation注解

func getAllAnnotations()

public func getAllAnnotations(): Array<Annotation>

功能：获取作用于该对象的所有自定义注解。

返回值：

Array<Annotation> - 作用于该对象的所有注解。

示例：

package test

import std.reflect.*

// 定义一个注解用于演示
@Annotation
public class MyAnnotation {
    public const init() {}
}

// 定义另一个注解用于演示
@Annotation
public class AnotherAnnotation {
    public const init() {}
}

// 定义一个带注解的类和静态函数用于演示
public class TestClass {
    @MyAnnotation
    @AnotherAnnotation
    public static func annotatedFunction(): String {
        return "This function has annotations"
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态函数信息
    let staticFunctions = classInfo.staticFunctions
    for (staticFunction in staticFunctions) {
        if (staticFunction.name == "annotatedFunction") {
            let allAnnotations = staticFunction.getAllAnnotations()
            println("总注解数量: ${allAnnotations.size}")
            break
        }
    }

    return
}

运行结果：

总注解数量: 2

func hashCode()

public func hashCode(): Int64

功能：获取该静态成员函数信息的哈希值。

返回值：

Int64 - 该静态成员函数信息的哈希值。

示例：

package test

import std.reflect.*

// 定义一个类和静态函数用于演示
public class TestClass {
    public static func processData(): String {
        return "Processing data"
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态函数信息
    let staticFunctions = classInfo.staticFunctions
    for (staticFunction in staticFunctions) {
        if (staticFunction.name == "processData") {
            let hash = staticFunction.hashCode()
            println("静态函数哈希值: ${hash}")
            break
        }
    }

    return
}

可能的运行结果：

静态函数哈希值: 94660305794880

func toString()

public func toString(): String

功能：获取字符串形式的该静态成员函数信息。

返回值：

String - 字符串形式的该静态成员函数信息。

示例：

package test

import std.reflect.*

// 定义一个类和静态函数用于演示
public class TestClass {
    public static func processData(): String {
        return "Processing data"
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态函数信息
    let staticFunctions = classInfo.staticFunctions
    for (staticFunction in staticFunctions) {
        if (staticFunction.name == "processData") {
            let str = staticFunction.toString()
            println("静态函数字符串表示: ${str}")
            break
        }
    }

    return
}

运行结果：

静态函数字符串表示: static func processData(): String

operator func !=(StaticFunctionInfo)

public operator func !=(other: StaticFunctionInfo): Bool

功能：判断该静态成员函数信息与给定的另一个静态成员函数信息是否不等。

参数：

other: StaticFunctionInfo - 被比较相等性的另一个静态成员函数信息。

返回值：

Bool - 如果该静态成员函数信息与另一个不等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

// 定义一个类和静态函数用于演示
public class TestClass {
    public static func func1(): String {
        return "Function 1"
    }

    public static func func2(): Int64 {
        return 42
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态函数信息
    let staticFunctions = classInfo.staticFunctions.toArray()

    println("两个StaticFunctionInfo对象不相等: ${staticFunctions[0] != staticFunctions[1]}")

    return
}

运行结果：

两个StaticFunctionInfo对象不相等: true

operator func ==(StaticFunctionInfo)

public operator func ==(other: StaticFunctionInfo): Bool

功能：判断该静态成员函数信息与给定的另一个静态成员函数信息是否相等。

参数：

other: StaticFunctionInfo - 被比较相等性的另一个静态成员函数信息。

返回值：

Bool - 如果该静态成员函数信息与另一个相等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

// 定义一个类和静态函数用于演示
public class TestClass {
    public static func processData(): String {
        return "Processing data"
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态函数信息
    let staticFunctions = classInfo.staticFunctions.toArray()

    println("两个StaticFunctionInfo对象相等: ${staticFunctions[0] == staticFunctions[0]}")

    return
}

运行结果：

两个StaticFunctionInfo对象相等: true

class StaticPropertyInfo

public class StaticPropertyInfo <: Equatable<StaticPropertyInfo> & Hashable & ToString {}

功能：描述静态成员属性信息。

父类型：

prop annotations

public prop annotations: Collection<Annotation>

功能：获取所有作用于该 StaticPropertyInfo 所对应的静态成员属性的注解所组成的集合。

类型：Collection<Annotation>

示例：

package test

import std.reflect.*

// 定义一个注解用于演示
@Annotation
public class MyAnnotation {
    public const init() {}
}

// 定义一个带注解的类和静态属性用于演示
public class TestClass {
    @MyAnnotation
    public static prop testProperty: String {
        get() {
            "test value"
        }
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态属性信息
    let staticProperty = classInfo.getStaticProperty("testProperty")

    // 获取注解数量
    let annotations = staticProperty.annotations
    println("静态属性注解数量: ${annotations.size}")

    return
}

运行结果：

静态属性注解数量: 1

prop modifiers

public prop modifiers: Collection<ModifierInfo>

功能：获取该 StaticPropertyInfo 对应的静态成员属性所拥有的所有修饰符的信息，返回对应集合。

类型：Collection<ModifierInfo>

示例：

package test

import std.reflect.*

// 定义一个带修饰符的类和静态属性用于演示
public class TestClass {
    public static prop publicProperty: String {
        get() {
            "public value"
        }
    }

    private static prop privateProperty: String {
        get() {
            "private value"
        }
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态属性信息
    let staticProperty = classInfo.getStaticProperty("publicProperty")

    // 获取修饰符数量
    let modifiers = staticProperty.modifiers
    println("公共静态属性修饰符数量: ${modifiers.size}")

    return
}

运行结果：

公共静态属性修饰符数量: 1

prop name

public prop name: String

功能：获取该 StaticPropertyInfo 对应的静态成员属性的名称。

类型：String

示例：

package test

import std.reflect.*

// 定义一个类和静态属性用于演示
public class TestClass {
    public static prop propertyName: String {
        get() {
            "property value"
        }
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态属性信息
    let staticProperty = classInfo.getStaticProperty("propertyName")

    // 获取属性名称
    println("静态属性名称: ${staticProperty.name}")

    return
}

运行结果：

静态属性名称: propertyName

prop typeInfo

public prop typeInfo: TypeInfo

功能：获取该 StaticPropertyInfo 对应的静态成员属性的声明类型的类型信息。

类型：TypeInfo

示例：

package test

import std.reflect.*

// 定义一个类和静态属性用于演示
public class TestClass {
    public static prop stringValue: String {
        get() {
            "string value"
        }
    }

    public static prop intValue: Int64 {
        get() {
            42
        }
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态属性信息
    let staticProperty = classInfo.getStaticProperty("stringValue")

    // 获取属性类型信息
    let typeInfo = staticProperty.typeInfo
    println("静态属性类型: ${typeInfo.name}")

    return
}

运行结果：

静态属性类型: String

func findAllAnnotations<T>() where T <: Annotation

public func findAllAnnotations<T>(): Array<T> where T <: Annotation

功能：获取所有指定注解名称的自定义注解（通过泛型筛选）。

返回值：

Array<T> - 若无指定 T 类型的注解时，返回空数组；若有相关注解时，将所有该类型注解对象构成的数组返回。

示例：

package test

import std.reflect.*

// 定义注解用于演示
@Annotation
public class MyAnnotation {
    public const init() {}
}

@Annotation
public class AnotherAnnotation {
    public const init() {}
}

// 定义一个带注解的类和静态属性用于演示
public class TestClass {
    @MyAnnotation
    @AnotherAnnotation
    public static prop annotatedProperty: String {
        get() {
            "annotated value"
        }
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态属性信息
    let staticProperty = classInfo.getStaticProperty("annotatedProperty")

    // 查找所有指定类型的注解
    let myAnnotations = staticProperty.findAllAnnotations<MyAnnotation>()
    println("MyAnnotation注解数量: ${myAnnotations.size}")

    return
}

运行结果：

MyAnnotation注解数量: 1

func findAnnotation<T>() where T <: Annotation

public func findAnnotation<T>(): ?T where T <: Annotation

功能：尝试获取指定注解名称的自定义注解（通过泛型筛选）。

返回值：

?T - 如果成功匹配则返回该注解，重复标注或者无法匹配时返回 None。

示例：

package test

import std.reflect.*

// 定义注解用于演示
@Annotation
public class MyAnnotation {
    public const init() {}
}

// 定义一个带注解的类和静态属性用于演示
public class TestClass {
    @MyAnnotation
    public static prop annotatedProperty: String {
        get() {
            "annotated value"
        }
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态属性信息
    let staticProperty = classInfo.getStaticProperty("annotatedProperty")

    // 查找指定类型的注解
    let annotation = staticProperty.findAnnotation<MyAnnotation>()
    if (annotation.isSome()) {
        println("找到了MyAnnotation注解")
    } else {
        println("未找到MyAnnotation注解")
    }

    return
}

运行结果：

找到了MyAnnotation注解

func getAllAnnotations()

public func getAllAnnotations(): Array<Annotation>

功能：获取作用于该对象的所有自定义注解。

返回值：

Array<Annotation> - 作用于该对象的所有注解。

示例：

package test

import std.reflect.*

// 定义注解用于演示
@Annotation
public class MyAnnotation {
    public const init() {}
}

@Annotation
public class AnotherAnnotation {
    public const init() {}
}

// 定义一个带注解的类和静态属性用于演示
public class TestClass {
    @MyAnnotation
    @AnotherAnnotation
    public static prop annotatedProperty: String {
        get() {
            "annotated value"
        }
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态属性信息
    let staticProperty = classInfo.getStaticProperty("annotatedProperty")

    // 获取所有注解
    let allAnnotations = staticProperty.getAllAnnotations()
    println("总注解数量: ${allAnnotations.size}")

    return
}

运行结果：

总注解数量: 2

func getValue()

public func getValue(): Any

功能：获取该 StaticPropertyInfo 对应的静态成员属性的值。

返回值：

Any - 该静态成员属性的值。

示例：

package test

import std.reflect.*

public class Rectangular {
    public static prop sides: Int64 {
        get() {
            4
        }
    }
    public static prop angles: Int64 {
        get() {
            4
        }
    }
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 ClassTypeInfo，也可以通过实例获取 ClassTypeInfo
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 获取静态属性
    let sp = ty.getStaticProperty("sides")

    let result = sp.getValue() as Int64
    println(result)
    return
}

运行结果：

Some(4)

func hashCode()

public func hashCode(): Int64

功能：获取该静态成员属性信息的哈希值。

返回值：

Int64 - 该静态成员属性信息的哈希值。

示例：

package test

import std.reflect.*

// 定义一个类和静态属性用于演示
public class TestClass {
    public static prop testProperty: String {
        get() {
            "test value"
        }
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态属性信息
    let staticProperty = classInfo.getStaticProperty("testProperty")

    // 获取哈希值
    let hash = staticProperty.hashCode()
    println("静态属性哈希值: ${hash}")

    return
}

可能的运行结果：

静态属性哈希值: 94756514624640

func isMutable()

public func isMutable(): Bool

功能：判断该静态成员属性信息所对应的静态成员属性是否可修改。

返回值：

Bool - 如果该静态成员属性信息所对应的静态成员属性可被修改则返回 true ，否则返回 false。

示例：

package test

import std.reflect.*

// 定义一个类和静态属性用于演示
public class TestClass {
    public static prop immutableProperty: String {
        get() {
            "immutable value"
        }
    }

    public static mut prop mutableProperty: String {
        get() {
            "mutable value"
        }
        set(v) {}
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取不可变静态属性信息
    let immutableProperty = classInfo.getStaticProperty("immutableProperty")
    let isImmutableMutable = immutableProperty.isMutable()
    println("不可变属性是否可修改: ${isImmutableMutable}")

    // 获取可变静态属性信息
    let mutableProperty = classInfo.getStaticProperty("mutableProperty")
    let isMutableMutable = mutableProperty.isMutable()
    println("可变属性是否可修改: ${isMutableMutable}")

    return
}

运行结果：

不可变属性是否可修改: false
可变属性是否可修改: true

func setValue(Any)

public func setValue(newValue: Any): Unit

功能：设置该 StaticPropertyInfo 对应的静态成员属性的值。

参数：

newValue: Any - 新值。

异常：

IllegalSetException - 如果该静态成员属性信息所对应的静态成员属性不可修改，则抛出异常。
IllegalTypeException - 如果新值 newValue 的运行时类型不是该静态成员属性信息所对应的静态成员属性的声明类型的子类型，则抛出异常。

示例：

package test

import std.reflect.*

public class Rectangular {
    private static var valueArea = 0
    public static mut prop area: Int64 {
        get() {
            valueArea
        }
        set(v) {
            valueArea = v
        }
    }
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 ClassTypeInfo，也可以通过实例获取 ClassTypeInfo
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 获取静态属性
    let sp = ty.getStaticProperty("area")

    // 设置静态成员属性的值
    sp.setValue(10)
    let result = sp.getValue() as Int64
    println(result)
    return
}

运行结果：

Some(10)

func toString()

public func toString(): String

功能：获取字符串形式的该静态成员属性信息。

返回值：

String - 字符串形式的该静态成员属性信息。

示例：

package test

import std.reflect.*

// 定义一个类和静态属性用于演示
public class TestClass {
    public static prop testProperty: String {
        get() {
            "test value"
        }
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态属性信息
    let staticProperty = classInfo.getStaticProperty("testProperty")

    // 获取字符串表示
    let str = staticProperty.toString()
    println("静态属性字符串表示: ${str}")

    return
}

运行结果：

静态属性字符串表示: static prop testProperty: String

operator func !=(StaticPropertyInfo)

public operator func !=(other: StaticPropertyInfo): Bool

功能：判断该静态成员属性信息与给定的另一个静态成员属性信息是否不等。

参数：

other: StaticPropertyInfo - 被比较相等性的另一个静态成员属性信息。

返回值：

Bool - 如果该静态成员属性信息与另一个不等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

// 定义一个类和静态属性用于演示
public class TestClass {
    public static prop property1: String {
        get() {
            "value1"
        }
    }

    public static prop property2: Int64 {
        get() {
            42
        }
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态属性信息
    let property1 = classInfo.getStaticProperty("property1")
    let property2 = classInfo.getStaticProperty("property2")

    // 比较两个静态属性信息是否不相等
    let result = property1 != property2
    println("两个静态属性不相等: ${result}")

    return
}

运行结果：

两个静态属性不相等: true

operator func ==(StaticPropertyInfo)

public operator func ==(other: StaticPropertyInfo): Bool

功能：判断该静态成员属性信息与给定的另一个静态成员属性信息是否相等。

参数：

other: StaticPropertyInfo - 被比较相等性的另一个静态成员属性信息。

返回值：

Bool - 如果该静态成员属性信息与另一个相等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

// 定义一个类和静态属性用于演示
public class TestClass {
    public static prop property1: String {
        get() {
            "value1"
        }
    }
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态属性信息
    let property1 = classInfo.getStaticProperty("property1")

    // 比较两个静态属性信息是否相等
    let result = property1 == property1
    println("同一个静态属性相等: ${result}")

    return
}

运行结果：

同一个静态属性相等: true

class StaticVariableInfo

public class StaticVariableInfo <: Equatable<StaticVariableInfo> & Hashable & ToString {}

功能：描述静态成员变量信息。

父类型：

prop annotations

public prop annotations: Collection<Annotation>

功能：获取所有作用于该 StaticVariableInfo 对应的静态成员变量的自定义注解，返回对应集合。

类型：Collection<Annotation>

示例：

package test

import std.reflect.*

// 定义一个注解用于演示
@Annotation
public class MyAnnotation {
    public const init() {}
}

// 定义一个带注解的类和静态变量用于演示
public class TestClass {
    @MyAnnotation
    public static var testVariable: String = "test value"
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态变量信息
    let staticVariable = classInfo.getStaticVariable("testVariable")

    // 获取注解数量
    let annotations = staticVariable.annotations
    println("静态变量注解数量: ${annotations.size}")

    return
}

运行结果：

静态变量注解数量: 1

prop modifiers

public prop modifiers: Collection<ModifierInfo>

功能：获取该 StaticVariableInfo 对应的静态成员变量所拥有的所有修饰符的信息，返回对应集合。

类型：Collection<ModifierInfo>

示例：

package test

import std.reflect.*

// 定义一个带修饰符的类和静态变量用于演示
public class TestClass {
    public static var publicVariable: String = "public value"

    private static var privateVariable: String = "private value"
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态变量信息
    let staticVariable = classInfo.getStaticVariable("publicVariable")

    // 获取修饰符数量
    let modifiers = staticVariable.modifiers
    println("公共静态变量修饰符数量: ${modifiers.size}")

    return
}

运行结果：

公共静态变量修饰符数量: 1

prop name

public prop name: String

功能：获取该 StaticVariableInfo 对应的静态成员变量的名称。

类型：String

示例：

package test

import std.reflect.*

// 定义一个类和静态变量用于演示
public class TestClass {
    public static var variableName: String = "variable value"
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态变量信息
    let staticVariable = classInfo.getStaticVariable("variableName")

    // 获取变量名称
    println("静态变量名称: ${staticVariable.name}")

    return
}

运行结果：

静态变量名称: variableName

prop typeInfo

public prop typeInfo: TypeInfo

功能：获取该 StaticVariableInfo 对应的静态成员变量的声明类型的类型信息。

类型：TypeInfo

示例：

package test

import std.reflect.*

// 定义一个类和静态变量用于演示
public class TestClass {
    public static var stringValue: String = "string value"

    public static var intValue: Int64 = 42
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态变量信息
    let staticVariable = classInfo.getStaticVariable("stringValue")

    // 获取变量类型信息
    let typeInfo = staticVariable.typeInfo
    println("静态变量类型: ${typeInfo.name}")

    return
}

运行结果：

静态变量类型: String

func findAllAnnotations<T>() where T <: Annotation

public func findAllAnnotations<T>(): Array<T> where T <: Annotation

功能：获取所有指定注解名称的自定义注解（通过泛型筛选）。

返回值：

Array<T> - 若无指定 T 类型的注解时，返回空数组；若有相关注解时，将所有该类型注解对象构成的数组返回。

示例：

package test

import std.reflect.*

// 定义注解用于演示
@Annotation
public class MyAnnotation {
    public const init() {}
}

@Annotation
public class AnotherAnnotation {
    public const init() {}
}

// 定义一个带注解的类和静态变量用于演示
public class TestClass {
    @MyAnnotation
    @AnotherAnnotation
    public static var annotatedVariable: String = "annotated value"
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态变量信息
    let staticVariable = classInfo.getStaticVariable("annotatedVariable")

    // 查找所有指定类型的注解
    let myAnnotations = staticVariable.findAllAnnotations<MyAnnotation>()
    println("MyAnnotation注解数量: ${myAnnotations.size}")

    return
}

运行结果：

MyAnnotation注解数量: 1

func findAnnotation<T>() where T <: Annotation

public func findAnnotation<T>(): ?T where T <: Annotation

功能：尝试获取指定注解名称的自定义注解（通过泛型筛选）。

返回值：

?T - 如果成功匹配则返回该注解，重复标注或者无法匹配时返回 None。

示例：

package test

import std.reflect.*

// 定义注解用于演示
@Annotation
public class MyAnnotation {
    public const init() {}
}

// 定义一个带注解的类和静态变量用于演示
public class TestClass {
    @MyAnnotation
    public static var annotatedVariable: String = "annotated value"
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态变量信息
    let staticVariable = classInfo.getStaticVariable("annotatedVariable")

    // 查找指定类型的注解
    let annotation = staticVariable.findAnnotation<MyAnnotation>()
    match (annotation) {
        case Some(_) => println("找到了MyAnnotation注解")
        case None => println("未找到MyAnnotation注解")
    }

    return
}

运行结果：

找到了MyAnnotation注解

func getAllAnnotations()

public func getAllAnnotations(): Array<Annotation>

功能：获取作用于该对象的所有自定义注解。

返回值：

Array<Annotation> - 作用于该对象的所有注解。

示例：

package test

import std.reflect.*

// 定义注解用于演示
@Annotation
public class MyAnnotation {
    public const init() {}
}

@Annotation
public class AnotherAnnotation {
    public const init() {}
}

// 定义一个带注解的类和静态变量用于演示
public class TestClass {
    @MyAnnotation
    @AnotherAnnotation
    public static var annotatedVariable: String = "annotated value"
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态变量信息
    let staticVariable = classInfo.getStaticVariable("annotatedVariable")

    // 获取所有注解
    let allAnnotations = staticVariable.getAllAnnotations()
    println("所有注解数量: ${allAnnotations.size}")

    return
}

运行结果：

所有注解数量: 2

func getValue()

public func getValue(): Any

功能：获取该 StaticVariableInfo 对应的静态成员变量的值。

返回值：

Any - 该静态成员变量的值。

示例：

package test

import std.reflect.*

public class Rectangular {
    public static var area: Int64 = 10
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 ClassTypeInfo，也可以通过实例获取 ClassTypeInfo
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 获取静态变量
    let sv = ty.getStaticVariable("area")
    // 获取值
    println(sv.getValue() as Int64)
    return
}

运行结果：

Some(10)

func hashCode()

public func hashCode(): Int64

功能：获取该静态成员变量信息的哈希值。

返回值：

Int64 - 该静态成员变量信息的哈希值。

示例：

package test

import std.reflect.*

// 定义一个类和静态变量用于演示
public class TestClass {
    public static var testVariable: String = "test value"
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态变量信息
    let staticVariable = classInfo.getStaticVariable("testVariable")

    // 获取哈希值
    let hashValue = staticVariable.hashCode()
    println("静态变量信息的哈希值: ${hashValue}")

    return
}

可能的运行结果：

静态变量信息的哈希值: 94532229551216

func isMutable()

public func isMutable(): Bool

功能：判断该 StaticVariableInfo 对应的静态成员变量是否可修改。

返回值：

Bool - 如果该静态成员变量信息所对应的静态成员变量可被修改则返回 true ，否则返回 false。

示例：

package test

import std.reflect.*

// 定义一个类和静态变量用于演示
public class TestClass {
    public static var mutableVariable: String = "mutable value"

    public static let immutableVariable: String = "immutable value"
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取可变静态变量信息
    let mutableStaticVariable = classInfo.getStaticVariable("mutableVariable")
    let isMutable = mutableStaticVariable.isMutable()
    println("可变静态变量: ${isMutable}")

    // 获取不可变静态变量信息
    let immutableStaticVariable = classInfo.getStaticVariable("immutableVariable")
    let isImmutableMutable = immutableStaticVariable.isMutable()
    println("不可变静态变量: ${isImmutableMutable}")

    return
}

运行结果：

可变静态变量: true
不可变静态变量: false

func setValue(Any)

public func setValue(newValue: Any): Unit

功能：设置该 StaticVariableInfo 对应的静态成员变量的值。

参数：

newValue: Any - 新值。

异常：

IllegalSetException - 如果该 StaticVariableInfo 对应的静态成员变量不可修改，则抛出异常。
IllegalTypeException - 如果新值 newValue 的运行时类型不是该静态成员变量信息所对应的静态成员变量的声明类型的子类型，则抛出异常。

示例：

package test

import std.reflect.*

public class Rectangular {
    public static var area: Int64 = 10
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 ClassTypeInfo，也可以通过实例获取 ClassTypeInfo
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 获取静态变量
    let sv = ty.getStaticVariable("area")

    // 设置值
    sv.setValue(20)
    println(sv.getValue() as Int64)
    return
}

运行结果：

Some(20)

func toString()

public func toString(): String

功能：获取字符串形式的该静态成员变量信息。

返回值：

String - 字符串形式的该静态成员变量信息。

示例：

package test

import std.reflect.*

// 定义一个类和静态变量用于演示
public class TestClass {
    public static var testVariable: String = "test value"
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态变量信息
    let staticVariable = classInfo.getStaticVariable("testVariable")

    // 获取字符串表示
    let strRepresentation = staticVariable.toString()
    println("静态变量信息的字符串表示: ${strRepresentation}")

    return
}

运行结果：

静态变量信息的字符串表示: static testVariable: String

operator func !=(StaticVariableInfo)

public operator func !=(other: StaticVariableInfo): Bool

功能：判断该静态成员变量信息与给定的另一个静态成员变量信息是否不等。

参数：

other: StaticVariableInfo - 被比较相等性的另一个静态成员变量信息。

返回值：

Bool - 如果该静态成员变量信息与另一个不等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

// 定义一个类和静态变量用于演示
public class TestClass {
    public static var variable1: String = "value1"

    public static var variable2: String = "value2"
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态变量信息
    let staticVariable1 = classInfo.getStaticVariable("variable1")
    let staticVariable2 = classInfo.getStaticVariable("variable2")

    // 比较两个静态变量信息是否不等
    let result = staticVariable1 != staticVariable2
    println("两个静态变量不相等: ${result}")

    // 比较同一个静态变量信息
    let sameResult = staticVariable1 != staticVariable1
    println("同一个静态变量不相等: ${sameResult}")

    return
}

运行结果：

两个静态变量不相等: true
同一个静态变量不相等: false

operator func ==(StaticVariableInfo)

public operator func ==(other: StaticVariableInfo): Bool

功能：判断该静态成员变量信息与给定的另一个静态成员变量信息是否相等。

参数：

other: StaticVariableInfo - 被比较相等性的另一个静态成员变量信息。

返回值：

Bool - 如果该静态成员变量信息与另一个相等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

// 定义一个类和静态变量用于演示
public class TestClass {
    public static var variable1: String = "value1"

    public static var variable2: String = "value2"
}

main(): Unit {
    // 获取类信息
    let classInfo = ClassTypeInfo.get("test.TestClass")

    // 获取静态变量信息
    let staticVariable1 = classInfo.getStaticVariable("variable1")
    let staticVariable2 = classInfo.getStaticVariable("variable2")

    // 比较两个静态变量信息是否相等
    let result = staticVariable1 == staticVariable2
    println("两个静态变量相等: ${result}")

    // 比较同一个静态变量信息
    let sameResult = staticVariable1 == staticVariable1
    println("同一个静态变量相等: ${sameResult}")

    return
}

运行结果：

两个静态变量相等: false
同一个静态变量相等: true

class StructTypeInfo

public class StructTypeInfo <: TypeInfo {}

功能：描述 struct 类型的类型信息。

父类型：

TypeInfo

由于实现限制，目前 Struct 类型的变量/属性修改需要参考如下代码手动 box/unbox。

示例：

import std.reflect.*

public struct SA {
    public var v1 = 11
}

main() {
    var sa = SA()

    // 通过这行先包装成Any，否则无法修改v1的值
    let saObj: Any = sa
    StructTypeInfo.of<SA>().getInstanceVariable("v1").setValue(saObj, 22)
    sa = (saObj as SA).getOrThrow()
    println(sa.v1) // should be 22
}

prop constructors

public prop constructors: Collection<ConstructorInfo>

功能：获取该 StructTypeInfo 对应的 struct 的所有 public 构造函数信息，返回对应集合。

类型：Collection<ConstructorInfo>

示例：

package test

import std.reflect.*

public struct TestStruct {
    public var value: Int64 = 0

    public init() {}

    public init(value: Int64) {
        this.value = value
    }
}

main(): Unit {
    // 获取结构体类型信息
    let structTypeInfo = StructTypeInfo.of<TestStruct>()

    // 获取构造函数信息
    let constructors = structTypeInfo.constructors
    println("构造函数数量: ${constructors.size}")

    return
}

运行结果：

构造函数数量: 2

prop instanceVariables

public prop instanceVariables: Collection<InstanceVariableInfo>

功能：获取该 StructTypeInfo 对应的 struct 的所有 public 实例成员变量信息，返回对应集合。

类型：Collection<InstanceVariableInfo>

示例：

package test

import std.reflect.*

public struct TestStruct {
    public var publicVar: Int64 = 0
    var privateVar: Int64 = 1
    public let publicLet: String = "public"
}

main(): Unit {
    // 获取结构体类型信息
    let structTypeInfo = StructTypeInfo.of<TestStruct>()

    // 获取实例成员变量信息
    let instanceVariables = structTypeInfo.instanceVariables
    println("实例成员变量数量: ${instanceVariables.size}")

    return
}

运行结果：

实例成员变量数量: 2

prop staticVariables

public prop staticVariables: Collection<StaticVariableInfo>

功能：获取该 StructTypeInfo 对应的 struct 的所有 public 静态成员变量信息，返回对应集合。

类型：Collection<StaticVariableInfo>

示例：

package test

import std.reflect.*

public struct TestStruct {
    public static var staticVar: Int64 = 10
    public static let staticLet: String = "static"
    var instanceVar: Int64 = 5
}

main(): Unit {
    // 获取结构体类型信息
    let structTypeInfo = StructTypeInfo.of<TestStruct>()

    // 获取静态成员变量信息
    let staticVariables = structTypeInfo.staticVariables
    println("静态成员变量数量: ${staticVariables.size}")

    return
}

运行结果：

静态成员变量数量: 2

static func get(String)

public static redef func get(qualifiedName: String): StructTypeInfo

功能：获取给定 qualifiedName 所对应的类型的 StructTypeInfo。

参数：

qualifiedName: String - 类型的限定名称。

返回值：

StructTypeInfo - 类型的限定名称 qualifiedName 所对应的 Struct 类型的类型信息。

异常：

InfoNotFoundException - 如果无法获取与给定类型的限定名称 qualifiedName 匹配的类型所对应的类型信息，则抛出异常。
IllegalTypeException - 如果获取到的类型信息不是 StructTypeInfo，则抛出异常。

示例：

import std.reflect.*

public struct Rectangular {}

main(): Unit {
    let ty = StructTypeInfo.get("default.Rectangular")
    println(ty)
    return
}

运行结果：

default.Rectangular

static func of(Any)

public static redef func of(a: Any): StructTypeInfo

功能：获取给定的任意类型实例的运行时类型所对应的类型信息。

运行时类型是指在程序运行时，通过动态绑定确定的类型，运行时类型与实例对象相绑定。在继承等场景下运行时类型和静态类型可能不一致。

参数：

a: Any - 任意类型的实例。

返回值：

StructTypeInfo - 实例 a 的运行时类型所对应的类型信息。

异常：

InfoNotFoundException - 如果无法获得实例 a 的运行时类型所对应的类型信息，则抛出异常。
IllegalTypeException - 如果获取到的类型信息不是 StructTypeInfo，则抛出异常。

示例：

package test

import std.reflect.*

public struct Rectangular {}

main(): Unit {
    var r = Rectangular()
    let ty = StructTypeInfo.of(r)
    println(ty)
    return
}

运行结果：

test.Rectangular

static func of<T>()

public static redef func of<T>(): StructTypeInfo

功能：获取给定 T 类型对应的类型信息。

返回值：

StructTypeInfo - T 类型对应的类型信息。

异常：

InfoNotFoundException - 如果无法获得类型 T 所对应的类型信息，抛出异常。
IllegalTypeException - 如果获取到的类型信息不是 StructTypeInfo，则抛出异常。

示例：

import std.reflect.*

public struct Rectangular {}

main(): Unit {
    let ty = StructTypeInfo.of<Rectangular>()
    println(ty)
    return
}

运行结果：

default.Rectangular

func construct(Array<Any>)

public func construct(args: Array<Any>): Any

功能：在该 StructTypeInfo 对应的 struct 类型中根据实参列表搜索匹配的构造函数并调用，传入实参列表，返回调用结果。

参数：

args: Array<Any> - 实参列表。

返回值：

Any - 该 struct 类型的实例。

异常：

MisMatchException - 如果实参列表未能成功匹配任何该 struct 类型的 public 构造函数，则抛出异常
InvocationTargetException - 在被调用的构造函数内部抛出的任何异常均将被封装为 InvocationTargetException 异常并抛出。

示例：

import std.reflect.*

public struct Rectangular {
    public var length = 4
    public var width = 5
    public init() {}
    public init(length: Int64, width: Int64) {
        this.length = length
        this.width = width
    }
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 StructTypeInfo，也可以通过实例获取 StructTypeInfo
    let ty = StructTypeInfo.get("default.Rectangular")
    // 匹配构造函数并调用
    let v = ty.construct(2, 3) as Rectangular
    println(v.getOrThrow().length)
    return
}

运行结果：

func getConstructor(Array<TypeInfo>)

public func getConstructor(parameterTypes: Array<TypeInfo>): ConstructorInfo

功能：尝试在该 StructTypeInfo 对应的 struct 类型中获取与给定形参类型信息列表匹配的 public 构造函数的信息。

参数：

parameterTypes: Array<TypeInfo> - 形参类型信息列表。

返回值：

ConstructorInfo - 如果成功匹配则返回该 public 构造函数的信息。

异常：

InfoNotFoundException - 如果没找到对应 public 构造函数，则抛出异常。

示例：

package test

import std.reflect.*

public struct TestStruct {
    public var value: Int64 = 0

    public init() {}

    public init(value: Int64) {
        this.value = value
    }
}

main(): Unit {
    // 获取结构体类型信息
    let structTypeInfo = StructTypeInfo.of<TestStruct>()

    // 获取构造函数信息
    let int64TypeInfo = PrimitiveTypeInfo.get("Int64")
    let constructor = structTypeInfo.getConstructor([int64TypeInfo])
    println(constructor)

    return
}

运行结果：

init(Int64)

func getInstanceVariable(String)

public func getInstanceVariable(name: String): InstanceVariableInfo

功能：给定变量名称，尝试获取该 StructTypeInfo 对应的 struct 类型中匹配的实例成员变量的信息。

参数：

name: String - 变量名称。

返回值：

InstanceVariableInfo - 如果成功匹配则返回该实例成员变量的信息。

异常：

InfoNotFoundException - 如果没找到对应 public 实例成员变量，则抛出异常。

示例：

package test

import std.reflect.*

public class Rectangular {
    public var length = 4
    public var width = 5
    public var myName = ""
    public init() {}
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 ClassTypeInfo，也可以通过实例获取 ClassTypeInfo
    let ty = ClassTypeInfo.get("test.Rectangular")

    // 获取结构实例成员变量信息
    let ivi = ty.getInstanceVariable("myName")
    println(ivi)
    return
}

运行结果：

myName: String

func getStaticVariable(String)

public func getStaticVariable(name: String): StaticVariableInfo

功能：给定变量名称，尝试获取该 StructTypeInfo 对应的 struct 类型中匹配的静态成员变量的信息。

参数：

name: String - 变量名称。

返回值：

StaticVariableInfo - 如果成功匹配则返回该静态成员变量的信息。

异常：

InfoNotFoundException - 如果没找到对应 public 静态成员变量，则抛出异常。

示例：

package test

import std.reflect.*

public struct Rectangular {
    public static var area: Int64 = 10
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 StructTypeInfo，也可以通过实例获取 StructTypeInfo
    let ty = StructTypeInfo.get("test.Rectangular")

    // 获取静态变量
    let sv = ty.getStaticVariable("area")
    println(sv)
    return
}

运行结果：

static area: Int64

class TupleTypeInfo

public class TupleTypeInfo <: TypeInfo

功能：描述元组类型的类型信息。

父类型：

TypeInfo

prop elements

public prop elements: ReadOnlyList<TypeInfo>

功能：获取该 TupleTypeInfo 对应元组中各元素的类型信息列表，按元组声明顺序返回。

类型：ReadOnlyList<TypeInfo>

示例：

package test

import std.reflect.*

main(): Unit {
    let info = TupleTypeInfo.of((1, "abc", true))
    println(info.elements.size)
    println(info.elements[0].name)
    println(info.elements[1].name)
    println(info.elements[2].name)
    return
}

运行结果：

3
Int64
String
Bool

static func of(Any)

public redef static func of(instance: Any): TupleTypeInfo

功能：获取给定实例的运行时类型所对应的 TupleTypeInfo。

参数：

instance: Any - 运行时类型为元组的实例。

返回值：

TupleTypeInfo - 实例 instance 的运行时类型所对应的类型信息。

异常：

IllegalTypeException - 如果获取到的类型信息不是 TupleTypeInfo，则抛出异常。

示例：

package test

import std.reflect.*

main(): Unit {
    let info = TupleTypeInfo.of((1, "a"))
    println(info.name)
    return
}

运行结果：

Tuple<Int64, String>

static func of<T>()

public static redef func of<T>(): TupleTypeInfo

功能：获取给定类型 T 对应的 TupleTypeInfo。

返回值：

TupleTypeInfo - T 类型对应的元组类型信息。

异常：

IllegalTypeException - 如果获取到的类型信息不是 TupleTypeInfo，则抛出异常。

示例：

package test

import std.reflect.*

main(): Unit {
    let info = TupleTypeInfo.of<(Int64, Bool)>()
    println(info.name)
    return
}

运行结果：

Tuple<Int64, Bool>

func construct(Array<Any>)

public func construct(args: Array<Any>): Any

功能：按元组各元素的顺序传入实参列表，构造该 TupleTypeInfo 对应的元组实例，返回构造结果。

参数：

args: Array<Any> - 元组各元素的取值，顺序与元组声明一致。

返回值：

Any - 构造出的元组实例。

异常：

IllegalArgumentException - 如果 args 的数量与元组元素数量不一致，则抛出异常。
IllegalTypeException - 如果 args 中任一元素类型与对应元组元素类型不匹配，则抛出异常。

示例：

package test

import std.reflect.*

class C {
    public var v: Int64 = 0
    public init(val: Int64) {
        this.v = val
    }
}

struct S {
    public var v: Int64 = 0
    public init(val: Int64) {
        this.v = val
    }
}

main(): Unit {
    let tp = (1, S(0), C(1))
    let info = TupleTypeInfo.of(tp)
    let constructed = (info.construct([42, S(99), C(100)]) as (Int64, S, C)).getOrThrow()
    println(constructed[0])
    println(constructed[1].v)
    println(constructed[2].v)
    return
}

运行结果：

42
99
100

func destruct(Any)

public func destruct(instance: Any): ReadOnlyList<Any>

功能：将指定元组实例拆解为各元素的只读列表并返回。

参数：

instance: Any - 该 TupleTypeInfo 对应类型的实例。

返回值：

ReadOnlyList<Any> - 元组实例中的元素值列表，顺序与元组声明一致。

异常：

IllegalTypeException - 如果 instance 的运行时类型与该 TupleTypeInfo 不一致，则抛出异常。

示例：

package test

import std.reflect.*

class C {
    public var v: Int64 = 0
    public init(val: Int64) {
        this.v = val
    }
}

struct S {
    public var v: Int64 = 0
    public init(val: Int64) {
        this.v = val
    }
}

main(): Unit {
    let tp = (1, S(0), C(1))
    let info = TupleTypeInfo.of(tp)
    let destructed = info.destruct(tp)
    println(destructed.size)
    println(destructed[0] as Int64)
    println((destructed[1] as S)?.v)
    println((destructed[2] as C)?.v)
    return
}

运行结果：

3
Some(1)
Some(0)
Some(1)

class TypeInfo

sealed abstract class TypeInfo <: Equatable<TypeInfo> & Hashable & ToString

功能：TypeInfo 提供了所有数据类型通用的操作接口。开发者通常无需向下转型为更具体的数据类型，如 ClassTypeInfo 等，就能进行反射操作。

TypeInfo 的子类包括 PrimitiveTypeInfo、StructTypeInfo、ClassTypeInfo 和 InterfaceTypeInfo，分别对应基本数据类型，struct 数据类型，class 数据类型和 interface 数据类型的类型信息。

父类型：

prop annotations

public prop annotations: Collection<Annotation>

功能：获取所有作用于该 TypeInfo 对应的类型的自定义注解，返回对应集合。

类型：Collection<Annotation>

示例：

package test

import std.reflect.*

// 定义一个注解
@Annotation
public class MyAnnotation {
    public const init() {}
}

// 定义一个带注解的类
@MyAnnotation
public class TestClass {}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.of<TestClass>()

    // 获取注解信息
    let annotations = typeInfo.annotations
    println("注解数量: ${annotations.size}")

    return
}

运行结果：

注解数量: 1

prop instanceFunctions

public prop instanceFunctions: Collection<InstanceFunctionInfo>

功能：获取该 TypeInfo 对应类型的所有 public 实例成员函数信息，返回对应集合。

类型：Collection<InstanceFunctionInfo>

示例：

package test

import std.reflect.*

public class TestClass {
    public func publicMethod(): Int64 {
        return 42
    }

    private func privateMethod(): Int64 {
        return 24
    }
}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.of<TestClass>()

    // 获取实例函数信息
    let instanceFunctions = typeInfo.instanceFunctions
    println("公共实例函数数量: ${instanceFunctions.size}")

    return
}

运行结果：

公共实例函数数量: 1

prop instanceProperties

public prop instanceProperties: Collection<InstancePropertyInfo>

功能：获取该 TypeInfo 对应类型的所有 public 实例成员属性信息，返回对应集合。

类型：Collection<InstancePropertyInfo>

示例：

package test

import std.reflect.*

public class TestClass {
    public var publicVar: Int64 = 10
    public prop publicProp: Int64 {
        get() {
            20
        }
    }

    private var privateVar: Int64 = 30
}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.of<TestClass>()

    // 获取实例属性信息
    let instanceProperties = typeInfo.instanceProperties
    println("公共实例属性数量: ${instanceProperties.size}")

    return
}

运行结果：

公共实例属性数量: 1

prop modifiers

public prop modifiers: Collection<ModifierInfo>

功能：获取该 TypeInfo 对应的类型拥有的所有修饰符的信息，返回对应集合。

类型：Collection<ModifierInfo>

示例：

package test

import std.reflect.*

public open class TestClass {
    public var publicVar: Int64 = 10
}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.of<TestClass>()

    // 获取修饰符信息
    let modifiers = typeInfo.modifiers
    println("修饰符数量: ${modifiers.size}")

    return
}

运行结果：

修饰符数量: 1

prop name

public prop name: String

功能：获取该 TypeInfo 对应的类型的名称。

类型：String

示例：

package test

import std.reflect.*

public class TestClass {
    public var publicVar: Int64 = 10
}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.of<TestClass>()

    // 获取类型名称
    let name = typeInfo.name
    println("类型名称: ${name}")

    return
}

运行结果：

类型名称: TestClass

prop qualifiedName

public prop qualifiedName: String

功能：获取该 TypeInfo 对应的类型的限定名称。

类型：String

示例：

package test

import std.reflect.*

public class TestClass {
    public var publicVar: Int64 = 10
}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.of<TestClass>()

    // 获取限定名称
    let qualifiedName = typeInfo.qualifiedName
    println("限定名称: ${qualifiedName}")

    return
}

运行结果：

限定名称: test.TestClass

prop staticFunctions

public prop staticFunctions: Collection<StaticFunctionInfo>

功能：获取该 TypeInfo 对应类型的所有 public 静态成员函数信息，返回对应集合。

类型：Collection<StaticFunctionInfo>

示例：

package test

import std.reflect.*

public class TestClass {
    public static func publicStaticMethod(): Int64 {
        return 42
    }

    private static func privateStaticMethod(): Int64 {
        return 24
    }
}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.of<TestClass>()

    // 获取静态函数信息
    let staticFunctions = typeInfo.staticFunctions
    println("公共静态函数数量: ${staticFunctions.size}")

    return
}

运行结果：

公共静态函数数量: 1

prop staticProperties

public prop staticProperties: Collection<StaticPropertyInfo>

功能：获取该 TypeInfo 对应类型的所有 public 静态成员属性信息，返回对应集合。

类型：Collection<StaticPropertyInfo>

示例：

package test

import std.reflect.*

public class TestClass {
    public static var publicStaticVar: Int64 = 10
    public static prop publicStaticProp: Int64 {
        get() {
            20
        }
    }

    private static var privateStaticVar: Int64 = 30
}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.of<TestClass>()

    // 获取静态属性信息
    let staticProperties = typeInfo.staticProperties
    println("公共静态属性数量: ${staticProperties.size}")

    return
}

运行结果：

公共静态属性数量: 1

prop superInterfaces

public prop superInterfaces: Collection<InterfaceTypeInfo>

功能：获取该 TypeInfo 对应的类型直接实现的所有 interface 类型的信息，返回对应集合。

类型：Collection<InterfaceTypeInfo>

示例：

package test

import std.reflect.*

public interface MyInterface {}

public class TestClass <: MyInterface {}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.of<TestClass>()

    // 获取父接口信息
    let superInterfaces = typeInfo.superInterfaces.toArray()
    for (superInterface in superInterfaces) {
        println("父接口名称: ${superInterface.name}")
    }
    return
}

运行结果：

父接口名称: MyInterface
父接口名称: Any

static func get(String)

public static func get(qualifiedName: String): TypeInfo

功能：获取给定 qualifiedName 所对应的类型的 TypeInfo。

参数：

qualifiedName: String - 类型的限定名称。

返回值：

TypeInfo - 类型的限定名称 qualifiedName 所对应的类型的类型信息。

异常：

InfoNotFoundException - 如果无法获取与给定类型的限定名称 qualifiedName 匹配的类型所对应的类型信息，则抛出异常。

示例：

import std.reflect.*

public class Rectangular {}

main(): Unit {
    let ty = TypeInfo.get("default.Rectangular")
    println(ty)
    return
}

运行结果：

default.Rectangular

static func of(Any)

public static func of(a: Any): TypeInfo

功能：获取给定的任意类型实例的运行时类型所对应的类型信息。

运行时类型是指在程序运行时，通过动态绑定确定的类型，运行时类型与实例对象相绑定。在继承等场景下运行时类型和静态类型可能不一致。

参数：

a: Any - 任意类型的实例。

返回值：

TypeInfo - 实例 a 的运行时类型所对应的类型信息。

异常：

InfoNotFoundException - 如果无法获得实例 a 的运行时类型所对应的类型信息，则抛出异常。

示例：

package test

import std.reflect.*

public class Rectangular {}

main(): Unit {
    var r: Any = Rectangular()
    let ty = TypeInfo.of(r)
    println(ty)
    return
}

运行结果：

test.Rectangular

static func of(Object) ^(deprecated)

public static func of(a: Object): ClassTypeInfo

功能：获取给定的 class 类型的实例的运行时类型所对应的 class 类型信息。

参数：

a: Object - class 类型的实例。

返回值：

ClassTypeInfo - class 类型的实例 a 的运行时类型所对应的 class 类型信息。

异常：

InfoNotFoundException - 如果无法获得实例 a 的运行时类型所对应的 class 类型信息，则抛出异常。

示例：

package test

import std.reflect.*

public class Rectangular {}

main(): Unit {
    var r: Object = Rectangular()
    let ty = TypeInfo.of(r)
    println(ty)
    return
}

运行结果：

test.Rectangular

static func of<T>()

public static func of<T>(): TypeInfo

功能：获取给定 T 类型对应的类型信息。

返回值：

TypeInfo - T 类型对应的类型信息。

异常：

InfoNotFoundException - 如果无法获得类型 T 所对应的类型信息，抛出异常。

示例：

import std.reflect.*

public class Rectangular {}

main(): Unit {
    let ty = TypeInfo.of<Rectangular>()
    println(ty)
    return
}

运行结果：

default.Rectangular

func findAllAnnotations<T>() where T <: Annotation

public func findAllAnnotations<T>(): Array<T> where T <: Annotation

功能：获取所有指定注解名称的自定义注解（通过泛型筛选）。

返回值：

Array<T> - 若无指定 T 类型的注解时，返回空数组；若有相关注解时，将所有该类型注解对象构成的数组返回。

示例：

package test

import std.reflect.*

// 定义注解
@Annotation
public class MyAnnotation {
    public const init() {}
}

@Annotation
public class AnotherAnnotation {
    public const init() {}
}

// 定义一个带注解的类
@MyAnnotation
@AnotherAnnotation
public class TestClass {}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.of<TestClass>()

    // 查找所有指定类型的注解
    let myAnnotations = typeInfo.findAllAnnotations<MyAnnotation>()
    println("MyAnnotation注解数量: ${myAnnotations.size}")

    return
}

运行结果：

MyAnnotation注解数量: 1

func findAnnotation<T>() where T <: Annotation

public func findAnnotation<T>(): ?T where T <: Annotation

功能：尝试获取指定注解名称的自定义注解（通过泛型筛选）。

返回值：

?T - 如果成功匹配则返回该注解，重复标注或者无法匹配时返回 None。

示例：

package test

import std.reflect.*

// 定义注解
@Annotation
public class MyAnnotation {
    public const init() {}
}

// 定义一个带注解的类
@MyAnnotation
public class TestClass {}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.of<TestClass>()

    // 查找指定类型的注解
    let annotation: ?MyAnnotation = typeInfo.findAnnotation<MyAnnotation>()
    match (annotation) {
        case Some(_) => println("找到了MyAnnotation注解")
        case None => println("未找到MyAnnotation注解")
    }

    return
}

运行结果：

找到了MyAnnotation注解

func getAllAnnotations()

public func getAllAnnotations(): Array<Annotation>

功能：获取作用于该对象的所有自定义注解。

返回值：

Array<Annotation> - 作用于该对象的所有注解。

示例：

package test

import std.reflect.*

// 定义注解
@Annotation
public class MyAnnotation {
    public const init() {}
}

@Annotation
public class AnotherAnnotation {
    public const init() {}
}

// 定义一个带注解的类
@MyAnnotation
@AnotherAnnotation
public class TestClass {}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.of<TestClass>()

    // 获取所有注解
    let allAnnotations = typeInfo.getAllAnnotations()
    println("所有注解数量: ${allAnnotations.size}")

    return
}

运行结果：

所有注解数量: 2

func getInstanceFunction(String, Array<TypeInfo>)

public func getInstanceFunction(name: String, parameterTypes: Array<TypeInfo>): InstanceFunctionInfo

功能：给定函数名称与函数形参类型列表所对应的类型信息列表，尝试获取该类型中匹配的实例成员函数的信息。

参数：

name: String - 函数名称。
parameterTypes: Array<TypeInfo> - 函数形参类型列表所对应的类型信息列表。

返回值：

InstanceFunctionInfo - 如果成功匹配则返回该实例成员函数的信息。

异常：

InfoNotFoundException - 如果没找到对应 public 实例成员函数，则抛出异常。

示例：

import std.reflect.*

public class Rectangular {
    public var length = 4
    public var width = 5
    public func area(): Int64 {
        return length * width
    }
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 TypeInfo，也可以通过实例获取 TypeInfo
    let ty = TypeInfo.get("default.Rectangular")
    // 获取 InstanceFunctionInfo
    var gif = ty.getInstanceFunction("area")

    println(gif)
    return
}

运行结果：

func area(): Int64

func getInstanceFunctions(String)

public func getInstanceFunctions(name: String): Array<InstanceFunctionInfo>

功能：给定函数名称，尝试获取该类型中所有匹配的实例成员函数的信息。

参数：

name: String - 函数名称。

返回值：

Array<InstanceFunctionInfo> - 如果成功匹配则返回所有匹配到的实例成员函数信息。

示例：

import std.reflect.*

public class Rectangular {
    public var length = 4
    public var width = 5
    public func area(): Int64 {
        return length * width
    }
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 TypeInfo，也可以通过实例获取 TypeInfo
    let ty = TypeInfo.get("default.Rectangular")
    // 获取 InstanceFunctionInfo
    var gif = ty.getInstanceFunctions("area")

    println(gif)
    return
}

运行结果：

[func area(): Int64]

func getInstanceProperty(String)

public func getInstanceProperty(name: String): InstancePropertyInfo

功能：尝试获取该类型中与给定属性名称匹配的实例成员属性的信息。

参数：

name: String - 属性名称。

返回值：

InstancePropertyInfo - 如果成功匹配则返回该实例成员属性的信息。

异常：

InfoNotFoundException - 如果没找到对应 public 实例成员属性，则抛出异常。

示例：

import std.reflect.*

public class Rectangular {
    public var length = 4
    public prop width: Int64 {
        get() {
            5
        }
    }
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 TypeInfo，也可以通过实例获取 TypeInfo
    let ty = TypeInfo.get("default.Rectangular")
    // 获取 InstancePropertyInfo
    var gip = ty.getInstanceProperty("width")

    println(gip)
    return
}

运行结果：

prop width: Int64

func getStaticFunction(String, Array<TypeInfo>)

public func getStaticFunction(name: String, parameterTypes: Array<TypeInfo>): StaticFunctionInfo

功能：通过给定函数名称与函数形参类型列表所对应的类型信息列表，尝试获取该类型中匹配的静态成员函数的信息。

参数：

name: String - 函数名称。
parameterTypes: Array<TypeInfo> - 函数形参类型列表所对应的类型信息列表。

返回值：

StaticFunctionInfo - 如果成功匹配则返回该静态成员函数的信息。

异常：

InfoNotFoundException - 如果没找到对应 public 静态成员函数，则抛出异常。

示例：

package test

import std.reflect.*

public class MyClass {
    public static func myFunc(): String {
        "Hello World"
    }

    public static func myFuncWithParam(value: Int64): String {
        "Hello ${value}"
    }
}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.get("test.MyClass")

    // 获取带参数静态函数信息
    // 通过已有函数的参数类型来获取类型信息
    let function = typeInfo.getStaticFunction("myFuncWithParam", [PrimitiveTypeInfo.get("Int64")])
    println(function)
    return
}

运行结果：

static func myFuncWithParam(Int64): String

func getStaticFunctions(String)

public func getStaticFunctions(name: String): Array<StaticFunctionInfo>

功能：给定函数名称，尝试获取该类型中所有匹配的静态成员函数的信息。

参数：

name: String - 函数名称。

返回值：

Array<StaticFunctionInfo> - 如果成功匹配则返回所有匹配到的静态成员函数信息。

示例：

package test

import std.reflect.*

public class Rectangular {
    public static func myName(): String {
        ""
    }
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 TypeInfo，也可以通过实例获取 TypeInfo
    let ty = TypeInfo.get("test.Rectangular")

    // 获取静态函数
    let sf = ty.getStaticFunctions("myName")

    println(sf)
    return
}

运行结果：

[static func myName(): String]

func getStaticProperty(String)

public func getStaticProperty(name: String): StaticPropertyInfo

功能：尝试获取该类型中与给定属性名称匹配的静态成员属性的信息。

参数：

name: String - 属性名称。

返回值：

StaticPropertyInfo - 如果成功匹配则返回该静态成员属性的信息。

异常：

InfoNotFoundException - 如果没找到对应 public 静态成员属性，则抛出异常。

示例：

package test

import std.reflect.*

public class Rectangular {
    private static var valueArea = 0
    public static mut prop area: Int64 {
        get() {
            valueArea
        }
        set(v) {
            valueArea = v
        }
    }
}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 TypeInfo，也可以通过实例获取 TypeInfo
    let ty = TypeInfo.get("test.Rectangular")

    // 获取静态属性
    let sp = ty.getStaticProperty("area")

    println(sp)
    return
}

运行结果：

static mut prop area: Int64

func hashCode()

public func hashCode(): Int64

功能：获取该类型信息的哈希值。

返回值：

Int64 - 该类型信息的哈希值。

示例：

package test

import std.reflect.*

public class TestClass {
    public var publicVar: Int64 = 10
}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.of<TestClass>()

    // 获取哈希值
    let hashCode = typeInfo.hashCode()
    println("哈希值: ${hashCode}")

    return
}

可能的运行结果：

哈希值: 93845398479248

func isSubtypeOf(TypeInfo)

public func isSubtypeOf(supertype: TypeInfo): Bool

功能：判断当前 TypeInfo 实例对应的类型是否是参数中指定的 TypeInfo 实例表示的类型的子类型。

参数：

supertype: TypeInfo - 目标类型的类型信息。

返回值：

Bool - 如果该 TypeInfo 对应的类型是 supertype 所对应的类型的子类型则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public abstract class Rectangular {}

public class Square <: Rectangular {}

main(): Unit {
    // 此处是通过 Rectangular 的类型的限定名称获取 TypeInfo，也可以通过实例获取 TypeInfo
    let tyr = ClassTypeInfo.get("test.Rectangular")
    let tys = ClassTypeInfo.get("test.Square")
    println(tys.isSubtypeOf(tyr))
    return
}

运行结果：

true

func toString()

public func toString(): String

功能：获取字符串形式的该类型信息。

返回值：

String - 字符串形式的该类型信息。

示例：

package test

import std.reflect.*

public class TestClass {
    public var publicVar: Int64 = 10
}

main(): Unit {
    // 获取类型信息
    let typeInfo = TypeInfo.of<TestClass>()

    // 获取字符串表示
    let strRepresentation = typeInfo.toString()
    println("字符串表示: ${strRepresentation}")

    return
}

运行结果：

字符串表示: test.TestClass

operator func !=(TypeInfo)

public operator func !=(other: TypeInfo): Bool

功能：判断该类型信息与给定的另一个类型信息是否不等。

参数：

other: TypeInfo - 被比较相等性的另一个类型信息。

返回值：

Bool - 如果该类型信息的限定名称与另一个不等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public class TestClass1 {
    public var publicVar: Int64 = 10
}

public class TestClass2 {
    public var publicVar: Int64 = 20
}

main(): Unit {
    // 获取类型信息
    let typeInfo1 = TypeInfo.of<TestClass1>()
    let typeInfo2 = TypeInfo.of<TestClass2>()

    // 比较两个类型信息是否不等
    let result = typeInfo1 != typeInfo2
    println("两个类型信息不等: ${result}")

    // 比较同一个类型信息
    let sameResult = typeInfo1 != typeInfo1
    println("同一个类型信息不等: ${sameResult}")

    return
}

运行结果：

两个类型信息不等: true
同一个类型信息不等: false

operator func ==(TypeInfo)

public operator func ==(other: TypeInfo): Bool

功能：判断该类型信息与给定的另一个类型信息是否相等。

参数：

other: TypeInfo - 被比较相等性的另一个类型信息。

返回值：

Bool - 如果该类型信息的限定名称与另一个相等则返回 true，否则返回 false。

示例：

package test

import std.reflect.*

public class TestClass1 {
    public var publicVar: Int64 = 10
}

public class TestClass2 {
    public var publicVar: Int64 = 20
}

main(): Unit {
    // 获取类型信息
    let typeInfo1 = TypeInfo.of<TestClass1>()
    let typeInfo2 = TypeInfo.of<TestClass2>()

    // 比较两个类型信息是否相等
    let result = typeInfo1 == typeInfo2
    println("两个类型信息相等: ${result}")

    // 比较同一个类型信息
    let sameResult = typeInfo1 == typeInfo1
    println("同一个类型信息相等: ${sameResult}")

    return
}

运行结果：

两个类型信息相等: false
同一个类型信息相等: true

Keyboard shortcuts