Integrate wiki docs

Author: orta

GLOSSARY.md

@@ -1,25 +1,47 @@
 ### Terminology from inside the codebase
 
-- `Parser` - Takes source code and tries to convert it into an in-memory AST representation which you can work
-  with in the compiler. Also: [see Parser](https://basarat.gitbooks.io/typescript/docs/compiler/parser.html)
-- `Scanner` - Used by the parser to convert a string an chops into tokens in a linear fashion, then it's up to a
-  parser to tree-ify them. Also: [see Scanner](https://basarat.gitbooks.io/typescript/docs/compiler/scanner.html)
-- `Binder` - Creates a symbol map and uses the AST to provide the type system
-  [See Binder](https://basarat.gitbooks.io/typescript/docs/compiler/binder.html)
-- `Checker` - Takes the AST, symbols and does the type checking and inference -
-  [See Checker](https://basarat.gitbooks.io/typescript/docs/compiler/checker.html)
-- `Token` - A set of characters with some kind of semantic meaning, a parser generates a set of tokens
-- `AST` - An abstract syntax tree. Basically the in-memory representation of all the identifiers as a tree of
-  tokens.
-- `Node` - An object that lives inside the tree
-- `Location` / `Range`
-- `Freshness` - When a literal type is first created and not expanded by hitting a mutable location, see [Widening
-  and Narrowing in TypeScript][wnn].
-- `Symbol` - An object that tracks all the places a variable or type is declared
-- `Transient Symbol` - A symbol created in the checker, as opposed to in the binder
+* **Core TypeScript Compiler**
+
+ * **Parser:** Starting from a set of sources, and following the productions of the language grammar, to generate an Abstract Syntax Tree (AST). Also: [see Parser](https://basarat.gitbooks.io/typescript/docs/compiler/parser.html),
+
+ * **Binder:** Linking declarations contributing to the same structure using a Symbol (e.g. different declarations of the same interface or module, or a function and a module with the same name). This allows the type system to reason about these named declarations. [See Binder](https://basarat.gitbooks.io/typescript/docs/compiler/binder.html)
+ * **Type resolver/ Checker:** Resolving types of each construct, checking semantic operations and generate diagnostics as appropriate. [See Checker](https://basarat.gitbooks.io/typescript/docs/compiler/checker.html)
+
+ * **Emitter:** Output generated from a set of inputs (.ts and .d.ts) files can be one of: JavaScript (.js), definitions (.d.ts), or source maps (.js.map)
+
+ * **Pre-processor:** The "Compilation Context" refers to all files involved in a "program". The context is created by inspecting all files passed in to the compiler on the command line, in order, and then adding any files they may reference directly or indirectly through `import` statements and `/// <reference path=... />` tags.
+The result of walking the reference graph is an ordered list of source files, that constitute the program.
+When resolving imports, preference is given to ".ts" files over ".d.ts" files to ensure the most up-to-date files are processed.
+The compiler does a node-like process to resolve imports by walking up the directory chain to find a source file with a .ts or .d.ts extension matching the requested import.
+Failed import resolution does not result in an error, as an ambient module could be already declared.
+
+* **Standalone compiler (tsc):** The batch compilation CLI. Mainly handle reading and writing files for different supported engines (e.g. Node.js)
+
+* **Language Service:** The "Language Service" exposes an additional layer around the core compiler pipeline that are best suiting editor-like applications.
+The language service supports the common set of a typical editor operations like statement completions, signature help, code formatting and outlining, colorization, etc... Basic re-factoring like rename, Debugging interface helpers like validating breakpoints as well as TypeScript-specific features like support of incremental compilation (--watch equivalent on the command-line). The language service is designed to efficiently handle scenarios with files changing over time within a long-lived compilation context; in that sense, the language service provides a slightly different perspective about working with programs and source files from that of the other compiler interfaces.
+> Please refer to the [[Using the Language Service API]] page for more details.
+
+* **Standalone Server (tsserver):** The `tsserver` wraps the compiler and services layer, and exposes them through a JSON protocol.
+> Please refer to the  [[Standalone Server (tsserver)]] for more details.
 
 ### Type stuff which can be see outside the compilers
 
+* Node: The basic building block of the Abstract Syntax Tree (AST). In general node represent non-terminals in the language grammar; some terminals are kept in the tree such as identifiers and literals.
+
+* SourceFile: The AST of a given source file. A SourceFile is itself a Node; it provides an additional set of interfaces to access the raw text of the file, references in the file, the list of identifiers in the file, and mapping from a position in the file to a line and character numbers.
+
+* Program: A collection of SourceFiles and a set of compilation options that represent a compilation unit. The program is the main entry point to the type system and code generation. 
+
+* Symbol: A named declaration. Symbols are created as a result of binding. Symbols connect declaration nodes in the tree to other declarations contributing to the same entity. Symbols are the basic building block of the semantic system. 
+
+* `Type`: Types are the other part of the semantic system. Types can be named (e.g. classes and interfaces), or anonymous (e.g. object types). 
+
+* Signature``: There are three types of signatures in the language: call, construct and index signatures.
+
+- `Transient Symbol` - A symbol created in the checker, as opposed to in the binder
+- `Freshness` - When a literal type is first created and not expanded by hitting a mutable location, see [Widening
+  and Narrowing in TypeScript][wnn].
+
 - `Expando` - This is [the term](https://developer.mozilla.org/en-US/docs/Glossary/Expando) used to describe taking a JS object and adding new things to it which expands the type's shape
 
   ```js

README.md

@@ -10,6 +10,53 @@ If you are completely new to the TypeScript codebase, this YouTube video covers
 
 <a href='https://www.youtube.com/watch?v=X8k_4tZ16qU&list=PLYUbsZda9oHu-EiIdekbAzNO0-pUM5Iqj&index=4'><img src="https://user-images.githubusercontent.com/49038/140491214-720ce354-e526-4599-94ec-72cdbecc2b01.png" /></a>
 
+
+<details>
+          <summary>If you are really short on time, here is a quick overview of the compilation process.</summary>
+
+The process starts with preprocessing. 
+The preprocessor figures out what files should be included in the compilation by following references (`/// <reference path=... />` tags, `require` and `import` statements).
+
+The parser then generates AST `Node`s. 
+These are just an abstract representation of the user input in a tree format. 
+A `SourceFile` object represents an AST for a given file with some additional information like the file name and source text. 
+
+The binder then passes over the AST nodes and generates and binds `Symbol`s.
+One `Symbol` is created for each named entity.
+There is a subtle distinction but several declaration nodes can name the same entity.
+That means that sometimes different `Node`s will have the same `Symbol`, and each `Symbol` keeps track of its declaration `Node`s.
+For example, a `class` and a `namespace` with the same name can *merge* and will have the same `Symbol`.
+The binder also handles scopes and makes sure that each `Symbol` is created in the correct enclosing scope.
+
+Generating a `SourceFile` (along with its `Symbol`s) is done through calling the `createSourceFile` API.
+
+So far, `Symbol`s represent named entities as seen within a single file, but several declarations can merge multiple files, so the next step is to build a global view of all files in the compilation  by building a `Program`.
+
+A `Program` is a collection of `SourceFile`s and a set of `CompilerOptions`.
+A `Program` is created by calling the `createProgram` API. 
+
+From a `Program` instance a `TypeChecker` can be created. 
+`TypeChecker` is the core of the TypeScript type system. 
+It is the part responsible for figuring out relationships between `Symbols` from different files, assigning `Type`s to `Symbol`s, and generating any semantic `Diagnostic`s (i.e. errors).
+
+The first thing a `TypeChecker` will do is to consolidate all the `Symbol`s from different `SourceFile`s into a single view, and build a single Symbol Table by "merging" any common `Symbol`s (e.g. `namespace`s spanning multiple files).  
+
+After initializing the original state, the `TypeChecker` is ready to answer any questions about the program.
+Such "questions" might be: 
+* What is the `Symbol` for this `Node`?
+* What is the `Type` of this `Symbol`?
+* What `Symbol`s are visible in this portion of the AST?
+* What are the available `Signature`s for a function declaration?
+* What errors should be reported for a file?
+
+The `TypeChecker` computes everything lazily; it only "resolves" the necessary information to answer a question.
+The checker will only examine `Node`s/`Symbol`s/`Type`s that contribute to the question at hand and will not attempt to examine additional entities.
+
+An `Emitter` can also be created from a given `Program`.
+The `Emitter` is responsible for generating the desired output for a given `SourceFile`; this includes `.js`, `.jsx`, `.d.ts`, and `.js.map` outputs. 
+ 
+</details>
+
 From there, you can start in the [First Steps to Contributing to the TypeScript Repo](https://github.com/microsoft/TypeScript-Compiler-Notes/tree/main/intro#the-typescript-compiler) consult the [Glossary](./GLOSSARY.md) or dive directly into the [`./codebase/`](./codebase) or [`./systems/`](./systems) folders.
 
 ## Asking Questions

codebase/src/compiler/scanner.md

@@ -81,6 +81,7 @@ doesn't do that.
 <!-- prettier-ignore-start -->
 [0]: ./parser.md
 [1]: <src/compiler/scanner.ts - export function createScanner>
+[1]: http://abc.com
 [2]: <src/compiler/scanner.ts - function setText(>
 [3]: GLOSSARY.md#incremental-parsing
 [4]: <src/compiler/scanner.ts - function scan(>