Вопрос: TypeScript ошибка: несовместимость типов в сравнении (TS2367)

Вопрос возник во время выполения задачи 1 (реализация унарного минуса)

Ссылка на мою ветку unminus

Ошибка возникает в классе SyntaxAnalyzer в методе scanTerm().
В методе scanTerm() есть цикл while. Условие для входа в цикл - текущий символ равен "*" или "/" и не равен null.

while (this.symbol !== null && (
                this.symbol.symbolCode === SymbolsCodes.star ||
                this.symbol.symbolCode === SymbolsCodes.slash
            ))

Далее в цикле для получения следующейго символа применяется метод nextSym().
Так как данный метод может вернуть "-", я хочу сделать проверку на равенство текущего символы "-".

if (this.symbol.symbolCode === SymbolsCodes.minus)

Вот при попытке сделать данную проверку получаю ошибку

This comparison appears to be unintentional because the types 'SymbolsCodes.star | SymbolsCodes.slash' and 'SymbolsCodes.minus' have no overlap.ts(2367)

При этом перед входом цикл while также есть проверка на раввенство текущего символа "-",
которая не вызывает ошибок

if (this.symbol.symbolCode === SymbolsCodes.minus)

Код класса

export class SyntaxAnalyzer {

    lexicalAnalyzer: LexicalAnalyzer;
    symbol: SymbolBase | null;

    /**
     * Деревья, которые будут построены (например, для каждой строки исходного кода)
     */
    trees: TreeNodeBase[];

    constructor(lexicalAnalyzer: LexicalAnalyzer) {
        this.lexicalAnalyzer = lexicalAnalyzer;
        this.symbol = null;
        this.trees = [];
    }

    /**
     * Перемещаемся по последовательности "символов" лексического анализатора,
     * получая очередной "символ" ("слово")
     */
    nextSym(): void {
        this.symbol = this.lexicalAnalyzer.nextSym();
    }

    accept(expectedSymbolCode: string): void {
        if (this.symbol === null) {
            throw `${expectedSymbolCode} expected but END OF FILE found!`;
        }

        if (this.symbol.symbolCode === expectedSymbolCode) {
            this.nextSym();
        } else {
            throw `${expectedSymbolCode} expected but ${this.symbol.symbolCode} found!`;
        }
    }

    analyze(): TreeNodeBase[] {
        this.nextSym();

        while (this.symbol !== null) {
            let expression: TreeNodeBase = this.scanExpression();

            this.trees.push(expression);

            // Последняя строка может не заканчиваться переносом на следующую строку.
            if (this.symbol !== null) {
                this.accept(SymbolsCodes.endOfLine);
            }
        }

        return this.trees;
    }

    /**
     * Разбор выражения
     */
    scanExpression(): TreeNodeBase {
        let term: TreeNodeBase = this.scanTerm();
        let operationSymbol: SymbolBase | null = null;

        while (this.symbol !== null && (
            this.symbol.symbolCode === SymbolsCodes.plus ||
            this.symbol.symbolCode === SymbolsCodes.minus
        )) {

            operationSymbol = this.symbol;
            this.nextSym();

            let secondTerm: TreeNodeBase = this.scanTerm();

            switch (operationSymbol.symbolCode) {
                case SymbolsCodes.plus:
                    term = new Addition(operationSymbol, term, secondTerm);
                    break;
                case SymbolsCodes.minus:
                    term = new Subtraction(operationSymbol, term, secondTerm);
                    break;
            }
        }

        return term;
    }

    /**
     * Разбор "слагаемого"
     */
    scanTerm(): TreeNodeBase {
        let multiplier: TreeNodeBase; 
        let operationSymbol: SymbolBase | null = null;

        if (this.symbol.symbolCode === SymbolsCodes.minus) { 
            operationSymbol = this.symbol;
            this.nextSym();
            multiplier = new UnaryMinus(operationSymbol, this.scanTerm())    
        } else {
            multiplier = this.scanMultiplier();

            while (this.symbol !== null && (
                this.symbol.symbolCode === SymbolsCodes.star ||
                this.symbol.symbolCode === SymbolsCodes.slash
            )) {
    
                operationSymbol = this.symbol;
                this.nextSym();

                let secondTerm: TreeNodeBase 
                
                / /   'ТУТ ОШБКА' 
                if (this.symbol.symbolCode === SymbolsCodes.minus) // 'ТУТ ОШБКА' 
                {
                    let minus = this.symbol;
                    this.nextSym();
                    secondTerm = new UnaryMinus(minus, this.scanTerm());
                } else {
                    secondTerm = this.scanMultiplier();
                }
    
                switch (operationSymbol.symbolCode) {
                    case SymbolsCodes.star:
                        multiplier = new Multiplication(operationSymbol, multiplier, secondTerm);
                        break;
                    case SymbolsCodes.slash:
                        multiplier = new Division(operationSymbol, multiplier, secondTerm);
                        break;
                }
            }
        }

        return multiplier;
    }

    /**
     *  Разбор "множителя"
     */
    scanMultiplier(): NumberConstant {
        let integerConstant: SymbolBase | null = this.symbol;

        this.accept(SymbolsCodes.integerConst); // проверим, что текущий символ это именно константа, а не что-то еще

        return new NumberConstant(integerConstant);
    }
};