Поведение при ошибках типов

SWC выполняет трансформацию TypeScript и современного JavaScript в исполняемый JavaScript, фокусируясь на синтаксическом анализе и генерации кода. В отличие от TypeScript-компилятора (tsc), система не предназначена для полноценной семантической проверки типов. Это фундаментально определяет поведение при наличии типовых ошибок.

Ключевая особенность: SWC не выполняет статическую проверку типов, он их удаляет в процессе трансформации.

TypeScript-часть входного кода рассматривается как расширенный синтаксис JavaScript. Типы, интерфейсы, дженерики и прочие конструкции существуют только на этапе парсинга и затем полностью элиминируются. 

function sum(a: number, b: number): number {
  return a + b;
}

sum("1", "2");

При обработке SWC данный код будет преобразован в: 

function sum(a, b) {
  return a + b;
}

sum("1", "2");

Ошибки несоответствия типов полностью игнорируются, поскольку для трансформатора они не являются частью исполняемой модели программы.

Разделение синтаксических и типовых ошибок

Поведение SWC при ошибках можно разделить на два принципиально разных класса:

Синтаксические ошибки

SWC строго проверяет корректность синтаксиса JavaScript/TypeScript. Ошибки на этом уровне приводят к немедленному падению трансформации.

Примеры: 

const a = ;

или 

function test( { return 1 }

Такие конструкции нарушают грамматику языка, и SWC не способен построить AST. В этом случае компиляция прерывается.

Свойство: синтаксические ошибки блокируют процесс компиляции полностью.

Типовые ошибки

Типовые ошибки относятся к семантическому уровню TypeScript и не влияют на структуру AST. 

const value: number = "text";
interface User {
  id: number;
}

const u: User = { id: "wrong" };

SWC:

  • не проверяет соответствие типов
  • не валидирует интерфейсы
  • не отслеживает несовместимость присваиваний
  • не анализирует generics

Свойство: типовые ошибки не обнаруживаются и не влияют на результат трансформации.

Внутренний pipeline SWC и влияние на ошибки

SWC построен как компилятор с этапами:

  1. Парсинг исходного кода (lexer + parser)
  2. Построение AST
  3. Трансформация AST (plugins / presets)
  4. Генерация JavaScript-кода

На этапе 1–2 обрабатывается только синтаксис. Типы TypeScript существуют как аннотации и игнорируются в semantic layer, которого в SWC нет в классическом виде.

Последствия отсутствия type-checking слоя

Отсутствие семантического анализатора приводит к следующим характеристикам:

  • невозможность выявления неверных типов на этапе сборки
  • отсутствие анализа совместимости модулей по типам
  • отсутствие проверки возвращаемых значений функций
  • отсутствие контроля strict-параметров TypeScript

Поведение при использовании TypeScript-парсера

При включении jsc.parser.typescript SWC начинает понимать TypeScript-синтаксис: 

{
  "jsc": {
    "parser": {
      "syntax": "typescript"
    }
  }
}

Это изменяет только грамматику входного языка, но не добавляет type-checking.

Важно

Поддержка TypeScript в SWC означает:

  • распознавание аннотаций типов
  • поддержку interface, enum, type
  • поддержку generics
  • корректное удаление типов при генерации JS

Не означает:

  • проверку типов
  • генерацию диагностик TypeScript

Ошибки, возникающие в процессе трансформации

Хотя типовые ошибки игнорируются, SWC может выдавать ошибки другого характера, связанные с невозможностью корректного разбора AST или применения трансформаций.

Ошибки парсинга TypeScript-синтаксиса 

type A = ;

Это синтаксически некорректное объявление типа, и SWC остановит обработку.

Конфликтные конструкции языка

Иногда ошибки возникают при неоднозначном синтаксисе: 

(<T>() => {})

Если конфигурация парсера не соответствует используемому стандарту ECMAScript, возможно падение компиляции.

Поведение в CLI и сборочных интеграциях

SWC используется в разных окружениях:

  • CLI (@swc/cli)
  • Webpack loader (swc-loader)
  • Rust core (@swc/core)
  • интеграции с bundler-ами (Next.js, Vite-плагины)

Во всех случаях сохраняется единая модель:

типовые ошибки не диагностируются на уровне SWC

CLI поведение

При выполнении: 

swc src -d dist

результат:

  • синтаксические ошибки → процесс завершается с ошибкой
  • типовые ошибки → игнорируются, выводится JS

Сравнение с TypeScript Compiler

Для понимания поведения SWC важно учитывать различие с tsc.

Возможность SWC TypeScript Compiler
Проверка типов нет да
Удаление типов да да
Проверка интерфейсов нет да
Ошибки несоответствия типов игнорируются диагностируются
Скорость очень высокая ниже
Семантический анализ отсутствует присутствует

Влияние на runtime-ошибки

Поскольку SWC не проверяет типы, несоответствия типов переходят в runtime.

Пример 

function multiply(a: number, b: number): number {
  return a * b;
}

multiply("2", "3");

После компиляции: 

function multiply(a, b) {
  return a * b;
}

multiply("2", "3");

Результат:

  • JavaScript выполнит оператор * с строками
  • произойдет неявное преобразование типов
  • возможен NaN в зависимости от значений

Следствие: ответственность за корректность типов переносится на разработчика или внешние инструменты.

Использование внешней проверки типов

Так как SWC не выполняет type-checking, часто применяется комбинированный подход:

  • SWC отвечает за трансформацию
  • TypeScript (tsc –noEmit) отвечает за проверку типов

Это приводит к разделению пайплайна: 

TypeScript source
      ↓
  tsc (type check only)
      ↓
   SWC (transpile)
      ↓
   JavaScript output

Поведение при strict-режимах TypeScript

Параметры вроде:

  • strict
  • noImplicitAny
  • strictNullChecks

полностью игнорируются SWC.

Причина: эти флаги относятся к semantic analysis layer TypeScript-компилятора, которого SWC не реализует.

Ошибки плагинов и трансформаций

SWC поддерживает плагины трансформации AST. В этом контексте могут возникать дополнительные ошибки, не связанные с типами:

  • некорректная модификация AST
  • несовместимость версии плагина и core
  • ошибки генерации кода после трансформации

Однако даже здесь типовая система TypeScript не участвует.

Поведение при mixed JS/TS проектах

В проектах, где одновременно используются JavaScript и TypeScript файлы, SWC:

  • обрабатывает оба типа файлов одинаково на уровне синтаксиса
  • не различает семантически строгие и нестрогие типы
  • удаляет TS-аннотации только там, где они присутствуют 
// JS
function a(x) {
  return x + 1;
}
// TS
function a(x: number): number {
  return x + 1;
}

Результат генерации будет идентичным по структуре.

Итоговые характеристики поведения при ошибках типов

SWC демонстрирует строго определённую модель обработки:

  • типы существуют только как синтаксический слой
  • ошибки типов не диагностируются
  • единственный критический класс ошибок — синтаксические
  • семантическая корректность программы не проверяется
  • ответственность за типовую безопасность переносится на внешние инструменты

Такая архитектура обеспечивает высокую скорость трансформации, но исключает участие SWC в процессе статического анализа типов.

Оглавление