Structural typing is not supported

Rule arkts-no-structural-typing

Severity: error

Currently, ArkTS does not support structural typing, i.e., the compiler cannot compare public APIs of two types and decide whether such types are identical. Use other mechanisms (inheritance, interfaces or type aliases) instead.

TypeScript

    interface I1 {
        f(): string
    }

    interface I2 { // I2 is structurally equivalent to I1
        f(): string
    }

    class X {
        n: number = 0
        s: string = ""
    }

    class Y { // Y is structurally equivalent to X
        n: number = 0
        s: string = ""
    }

    let x = new X()
    let y = new Y()

    console.log("Assign X to Y")
    y = x

    console.log("Assign Y to X")
    x = y

    function foo(x: X) {
        console.log(x.n, x.s)
    }

    // X and Y are equivalent because their public API is equivalent.
    // Thus the second call is allowed:
    foo(new X())
    foo(new Y())

ArkTS

    interface I1 {
        f(): string
    }

    type I2 = I1 // I2 is an alias for I1

    class B {
        n: number = 0
        s: string = ""
    }

    // D is derived from B, which explicitly set subtype / supertype relations:
    class D extends B {
        constructor() {
            super()
        }
    }

    let b = new B()
    let d = new D()

    console.log("Assign D to B")
    b = d // ok, B is the superclass of D

    // An attempt to assign b to d will result in a compile-time error:
    // d = b

    interface Common {
       n: number
       s: string
    }

    // X implements interface Z, which makes relation between X and Y explicit.
    class X implements Common {
        n: number = 0
        s: string = ""
    }

    // Y implements interface Z, which makes relation between X and Y explicit.
    class Y implements Common {
        n: number = 0
        s: string = ""
    }

    let x: Common = new X()
    let y: Common = new Y()

    console.log("Assign X to Y")
    y = x // ok, both are of the same type

    console.log("Assign Y to X")
    x = y // ok, both are of the same type

    function foo(c: Common): void {
        console.log(c.n, c.s)
    }

    // X and Y implement the same interface, thus both calls are allowed:
    foo(new X())
    foo(new Y())