# TypeScript Compiler Internals

The TypeScript compiler source is located under the [`src/compiler`](https://github.com/Microsoft/TypeScript/tree/master/src/compiler) folder.

It is split into the follow key parts:

* Scanner (`scanner.ts`)
* Parser (`parser.ts`)
* Binder (`binder.ts`)
* Checker (`checker.ts`)
* Emitter (`emitter.ts`)

Each of these get their own unique files in the source. These parts will be explained later on in this chapter.

## Syntax vs. Semantics

Just because something is *syntactically* correct doesn't mean it is *semantically* correct. Consider the following piece of TypeScript code which although *syntactically* valid is *semantically* wrong

```typescript
var foo: number = "not a number";
```

`Semantic` means "meaning" in English. This concept is useful to have in your head.

## Processing Overview

The following is a quick review of how these key parts of the TypeScript compiler compose:

```
SourceCode ~~ scanner ~~> Token Stream
```

```
Token Stream ~~ parser ~~> AST
```

```
AST ~~ binder ~~> Symbols
```

`Symbol` is the primary building block of the TypeScript *semantic* system. As shown the symbols are created as a result of binding. Symbols connect declaration nodes in the AST to other declarations contributing to the same entity.

Symbols + AST are what is used by the checker to *semantically* validate the source code

```
AST + Symbols ~~ checker ~~> Type Validation
```

Finally When a JS output is requested:

```
AST + Checker ~~ emitter ~~> JS
```

There are a few additional files in the TypeScript compiler that provide utilities to many of these key portions which we cover next.

## File: Utilities

`core.ts` : core utilities used by the TypeScript compiler. A few important ones:

* `let objectAllocator: ObjectAllocator` : is a variable defined as a singleton global. It provides the definitions for `getNodeConstructor` (Nodes are covered when we look at `parser` / `AST`), `getSymbolConstructor` (Symbols are covered in `binder`), `getTypeConstructor` (Types are covered in `checker`), `getSignatureConstructor` (Signatures are the index, call and construct signatures).

## File: Key Data Structures

`types.ts` contains key data structures and interfaces uses throughout the compiler. Here is a sampling of a few key ones:

* `SyntaxKind`

  The AST node type is identified by the `SyntaxKind` enum.
* `TypeChecker`

  This is the interface provided by the TypeChecker.
* `CompilerHost`

  This is used by the `Program` to interact with the `System`.
* `Node`

  An AST node.

## File: System

`system.ts`. All interaction of the TypeScript compiler with the operating system goes through a `System` interface. Both the interface and its implementations (`WScript` and `Node`) are defined in `system.ts`. You can think of it as the *Operating Environment* (OE).

Now that you have an overview of the major files, we can look at the concept of `Program`


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://basarat.gitbook.io/typescript/overview.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.