3.9

interface Foodstuff{
    isExpirationDate():boolean;
}
interface Milk extends Foodstuff {
}
interface Coffee extends Foodstuff {
}

async function factory(milkOrder: Promise<Milk>, coffeeOrder: Promise<Coffee | undefined>) {
    let [milk, coffee] = await Promise.all([milkOrder, coffeeOrder]);
    
    /**
     * [error] Object is possibly 'undefined'.
     * [сейчас] let milk: Milk | undefined
     * [должно] let milk: Milk
     * 
     * [ERROR] Ошибочное поведение!
     */
    milk.isExpirationDate();
    /**
     * [error] Object is possibly 'undefined'.
     * [сейчас] let milk: Coffee | undefined
     * 
     * [Ok] Ожидаемое\правильное поведение!
     */
    coffee.isExpirationDate();

}

// ...

async function factory(milkOrder: Promise<Milk>, coffeeOrder: Promise<Coffee | undefined>) {
    let [milk, coffee] = await Promise.all([milkOrder, coffeeOrder]);
    
    milk.isExpirationDate(); // Ok! let milk: Milk
    coffee.isExpirationDate(); // Error! let coffee: Coffee | undefined

}

function isStringAssert(valid:boolean): asserts valid {
    if(!valid){
        throw new Error(`...`);
    }
}

function action(value: string){
    isStringAssert(typeof value === "string"); // валидация времени выполнения

    // некоторый код...
}

// файл .ts

function isStringAssert(valid:boolean): asserts valid {
    if(!valid){
        throw new Error(`...`);
    }
}

function action(value: string){
    isStringAssert(typeof value === "string"); // валидация времени выполнения

    // некоторый код...
}

// ...где-то в .ts.spec

/**
 * [error] Argument of type '5' is not assignable to parameter of type 'string'.
 * Компилятор TypeScript не позволяет скомпилировать код имеющий ошибки вызванные
 * несоответствие типов и тем самым препятствует тестированию кода времени выполнения.
 */
action(5);

// @ts-expect-error
action(5); // Ok!
// @ts-expect-error
action('5'); // Error! Unused '@ts-expect-error' directive.

declare function isValid(): boolean;

function action(){
    /**
     * Начиная с версии 3.7
     * 
     * [error] This condition will always return true 
     * since the function is always defined.
     * Did you mean to call it instead?
     */
    if(isValid){
        /**
         * По факту этот блок кода будет
         * выполняться всегда, поскольку
         * в условном выражении участвует
         * ссылка на функцию, а не предполагаемый
         * результат её вызова!
         */
    }
}

declare function isValid(): boolean;

function action(){
    /**
     * Начиная с версии 3.9
     * 
     * [error] This condition will always return true 
     * since the function is always defined.
     * Did you mean to call it instead?
     */
    return isValid ? 'true' : 'false';
}

type T = {
    f0?: {
        f1?: any;
    }
}

function f(p?:T){
    p?.f0!.f1;
}

f({});

function f(p){
    /**
     * Обращение к f1 произойдет только в случае
     * существования параметра p и определения в
     * нем поля f0 ссылающегося на объект.
     *//
    p === null || p === void 0 ? void 0 : p.f0.f1;
}

function f(p){
    /**
     * Обращение к f1 произойдет даже в случае
     * если параметр p и\или поле f1 отсутствует,
     *, что приведет к ошибке во время выполнения.
     * Кроме того, подобное поведение в корне противоречит
     * ожидаемому разработчиком поведению оператора
     * опциональной последовательности.
     */
     (p === null || p === void 0 ? void 0 : p.f0).f1;
}

type T = {
    f0?: {
        f1?: any;
    }
}

function f(p?:T){
    /**
     * Указываем, что обращение к полю f1
     * должно произойти независимо от результата
     * выражения в круглых скобках.
     * 
     * После компиляции данный код примет подобный вид -
     * 
     * (p === null || p === void 0 ? void 0 : p.f0).f1;
     */
    (p?.f0)!.f1;
}

f({});

let text = [
    // Unexpected token. Did you mean `{'}'}` or `}`?
    <span>Text with closing curly bracket }.</span>,
    // Unexpected token. Did you mean `{'>'}` or `&gt;`?
    <span>Text with closing angle bracket >.</span>,
];

interface A {
    a: number;
}

interface B {
    b: string;
}

interface C {
    a?: boolean;
    b: string;
}

declare let x: A & B;
declare let y: C;

/**
 * Ok до версии 3.9, поскольку A можно присвоить C
 * и B можно присвоить C.
 */
y = x;

// ...код

/**
 * Error начиная с версии 3.9 -
 * 
 * Type 'A & B' is not assignable to type 'C'.
 * Types of property 'a' are incompatible.
 * Type 'number' is not assignable to type 'boolean | undefined'.
 */
y = x;

declare function join<T, U>(a: T, b: U): T & U;


interface NameInfo {
    type: "name";

    firstName: string;
    lastName: string;
}
interface AddressInfo {
    type: "address";

    country:string;
    city: string;
}


declare let nameInfo: NameInfo;
declare let addressInfo: AddressInfo;

/**
 * let person: NameInfo & AddressInfo
 */
let person = join(nameInfo, addressInfo);

/**
 * Ok, До версии 3.9
 */
person.type; // (property) type: never

// ...код


/**
 * let person: never
 */
let person = join(nameInfo, addressInfo);

/**
 * Error, Начиная с версии 3.9 -
 * 
 * Property 'type' does not exist on type 'never'.
 */
person.type; // (property) type: never

const f = <T extends any>(p: T) => {
    /**
     * [*]
     * До версии 3.9 - Ok
     * Начиная с версии 3.9 - Error ->
     * Property 'notExistsMethod' does not exist on type 'T'.
     */
    p.notExistsMethod(); // [*]
}

class T {
    set accessor(value: string){

    }
    get accessor(){
        return "accessor";
    }
}

"use strict";
var T = /** @class */ (function () {
    function T() {
    }
    Object.defineProperty(T.prototype, "accessor", {
        get: function () {
            return "accessor";
        },
        set: function (value) {
        },
        enumerable: false, // false начиная с версии 3.9, но true для версий ниже
        configurable: true
    });
    return T;
}());