Normalise braces, trailing whitespace, and EOL's

Author: James Whitney

docs/arrow-functions.md

@@ -1,42 +1,42 @@
 ### Arrow Functions
 
-Lovingly called the *fat arrow* (because `->` is a thin arrow and `=>` is a fat arrow) and also called a *lambda function* (because of other languages). Another commonly used feature is the fat arrow function `()=>something`. The motivation for a *fat arrow* is: 
+Lovingly called the *fat arrow* (because `->` is a thin arrow and `=>` is a fat arrow) and also called a *lambda function* (because of other languages). Another commonly used feature is the fat arrow function `()=>something`. The motivation for a *fat arrow* is:
 1. You don't need to keep typing `function`
 2. It lexically captures the meaning of `this`
 2. It lexically captures the meaning of `arguments`
 
-For a language that claims to be functional, in JavaScript you tend to be typing `function` quite a lot. The fat arrow makes it simple for you to create a function 
+For a language that claims to be functional, in JavaScript you tend to be typing `function` quite a lot. The fat arrow makes it simple for you to create a function
 ```ts
 var inc = (x)=>x+1;
 ```
-`this` has traditionally been a pain point in JavaScript. As a wise man once said "I hate JavaScript as it tends to lose the meaning of `this` all too easily". Fat arrows fix it by capturing the meaning of `this` from the surrounding context. Consider this pure JavaScript class: 
+`this` has traditionally been a pain point in JavaScript. As a wise man once said "I hate JavaScript as it tends to lose the meaning of `this` all too easily". Fat arrows fix it by capturing the meaning of `this` from the surrounding context. Consider this pure JavaScript class:
 
 ```ts
 function Person(age) {
     this.age = age
-    this.growOld = function(){
+    this.growOld = function() {
         this.age++;
     }
 }
-var person = new Person(1); 
+var person = new Person(1);
 setTimeout(person.growOld,1000);
 
-setTimeout(function(){ console.log(person.age); },2000); // 1, should have been 2
+setTimeout(function() { console.log(person.age); },2000); // 1, should have been 2
 ```
-If you run this code in the browser `this` within the function is going to point to `window` because `window` is going to be what executes the `growOld` function. Fix is to use an arrow function: 
+If you run this code in the browser `this` within the function is going to point to `window` because `window` is going to be what executes the `growOld` function. Fix is to use an arrow function:
 ```ts
 function Person(age) {
     this.age = age
     this.growOld = () => {
         this.age++;
     }
 }
-var person = new Person(1); 
+var person = new Person(1);
 setTimeout(person.growOld,1000);
 
-setTimeout(function(){ console.log(person.age); },2000); // 2
+setTimeout(function() { console.log(person.age); },2000); // 2
 ```
-The reason why this works is the reference to `this` is captured by the arrow function from outside the function body. This is equivalent to the following JavaScript code (which is what you would write yourself if you didn't have TypeScript): 
+The reason why this works is the reference to `this` is captured by the arrow function from outside the function body. This is equivalent to the following JavaScript code (which is what you would write yourself if you didn't have TypeScript):
 ```ts
 function Person(age) {
     this.age = age
@@ -45,33 +45,33 @@ function Person(age) {
         _this.age++;   // use the captured this
     }
 }
-var person = new Person(1); 
+var person = new Person(1);
 setTimeout(person.growOld,1000);
 
-setTimeout(function(){ console.log(person.age); },2000); // 2
+setTimeout(function() { console.log(person.age); },2000); // 2
 ```
-Note that since you are using TypeScript you can be even sweeter in syntax and combine arrows with classes: 
+Note that since you are using TypeScript you can be even sweeter in syntax and combine arrows with classes:
 ```ts
 class Person {
-    constructor(public age:number){}    
+    constructor(public age:number) {}
     growOld = () => {
         this.age++;
     }
 }
-var person = new Person(1); 
+var person = new Person(1);
 setTimeout(person.growOld,1000);
 
-setTimeout(function(){ console.log(person.age); },2000); // 2
+setTimeout(function() { console.log(person.age); },2000); // 2
 ```
 
 #### Tip: Arrow Function Need
-Beyond the terse syntax, you only *need* to use the fat arrow if you are going to give the function to someone else to call. Effectively: 
+Beyond the terse syntax, you only *need* to use the fat arrow if you are going to give the function to someone else to call. Effectively:
 ```ts
-var growOld = person.growOld; 
+var growOld = person.growOld;
 // Then later someone else calls it:
 growOld();
 ```
-If you are going to call it yourself, i.e. 
+If you are going to call it yourself, i.e.
 ```ts
 person.growOld();
 ```
@@ -86,7 +86,7 @@ Many libraries do this e.g `jQuery` iterables (one example http://api.jquery.com
 
 ```ts
 let _self = this;
-something.each(function(){
+something.each(function() {
     console.log(_self); // the lexically scoped value
     console.log(this); // the library passed value
 });

docs/classes-extensibility.md

@@ -1,10 +1,10 @@
 #### Class extensibility
 
-People often add properties to classes from other JavaScript libraries. Here is a simple JavaScript example of this: 
+People often add properties to classes from other JavaScript libraries. Here is a simple JavaScript example of this:
 
 ```js
 // Original Library
-function Foo{}
+function Foo {}
 
-// Third party extension to add new member properties 
+// Third party extension to add new member properties
 ```

docs/classes-super.md

@@ -1,6 +1,6 @@
 #### `super`
 
-Note that if you call `super` on a child class it is redirected to the `prototype` as shown below: 
+Note that if you call `super` on a child class it is redirected to the `prototype` as shown below:
 
 ```ts
 class Base {
@@ -11,7 +11,7 @@ class Child extends Base {
     log() { super.log() };
 }
 ```
-generates: 
+generates:
 
 ```js
 var Base = (function () {
@@ -56,8 +56,7 @@ module quz {
 
     class Child extends Base {
         // ERROR : only `public` and `protected` methods of base class are accessible via `super`
-        logWorld() { super.log() }; 
+        logWorld() { super.log() };
     }
 }
 ```
-

docs/classes.md

@@ -99,7 +99,7 @@ foo.z; // ERROR : protected
 
 // EFFECT ON CHILD CLASSES
 class FooChild extends FooBase {
-    constructor(){
+    constructor() {
       super();
         this.x; // okay
         this.y; // ERROR: private
@@ -120,18 +120,18 @@ As always these modifiers work for both member properties and member functions.
 Having a member in a class and initializing it like below:
 
 ```ts
-class Foo{
+class Foo {
     x: number;
-    constructor(x:number){
+    constructor(x:number) {
         this.x = x;
     }
 }
 ```
 is such a common pattern that TypeScript provides a shorthand where you can prefix the member with an *access modifier* and it is automatically declared on the class and copied from the constructor. So the previous example can be re-written as (notice `public x:number`):
 
 ```ts
-class Foo{
-    constructor(public x:number){
+class Foo {
+    constructor(public x:number) {
     }
 }
 ```
@@ -140,9 +140,9 @@ class Foo{
 This is a nifty feature supported by TypeScript (from ES7 actually). You can initialize any member of the class outside the class constructor, useful to provide default (notice `members = []`)
 
 ```ts
-class Foo{
+class Foo {
     members = [];  // Initialize directly
-    add(x){
+    add(x) {
         this.members.push(x);
     }
 }

docs/compiler-options.md

@@ -4,4 +4,4 @@
 /*!
  * License
  */
-```
+```

docs/compiler/ast-tip-children.md

@@ -25,7 +25,7 @@ export function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodeArr
 
 Basically it checks `node.kind` and based on that assumes an interface offered by the `node` and calls the `cbNode` on the children. Note however that this function doesn't call `visitNode` for *all* children (e.g. SyntaxKind.SemicolonToken). If you want *all* the children of a node in the AST just call `.getChildren` member function of the `Node`.
 
-E.g. here is a function that prints the verbose `AST` of a node: 
+E.g. here is a function that prints the verbose `AST` of a node:
 
 ```ts
 function printAllChildren(node: ts.Node, depth = 0) {
@@ -35,4 +35,4 @@ function printAllChildren(node: ts.Node, depth = 0) {
 }
 ```
 
-We will see a sample usage of this function when we discuss the parser further.
+We will see a sample usage of this function when we discuss the parser further.

docs/compiler/ast-tip-syntaxkind.md

@@ -1,6 +1,6 @@
 ### AST Tip: SyntaxKind
 
-`SyntaxKind` is defined as a `const enum`, here is a sample: 
+`SyntaxKind` is defined as a `const enum`, here is a sample:
 
 ```ts
 export const enum SyntaxKind {
@@ -10,11 +10,10 @@ export const enum SyntaxKind {
     // ... LOTS more
 ```
 
-It's a `const enum` (a concept [we covered previously](../enums.md)) so that it gets *inlined* (e.g. `ts.SyntaxKind.EndOfFileToken` becomes `1`) and we don't get a dereferencing cost when working with AST. However the compiler is compiled with `--preserveConstEnums` compiler flag so that the enum *is still available at runtime*. So in JavaScript you can use `ts.SyntaxKind.EndOfFileToken` if you want. Additionally you can convert these enum members to display strings using the following function: 
+It's a `const enum` (a concept [we covered previously](../enums.md)) so that it gets *inlined* (e.g. `ts.SyntaxKind.EndOfFileToken` becomes `1`) and we don't get a dereferencing cost when working with AST. However the compiler is compiled with `--preserveConstEnums` compiler flag so that the enum *is still available at runtime*. So in JavaScript you can use `ts.SyntaxKind.EndOfFileToken` if you want. Additionally you can convert these enum members to display strings using the following function:
 
 ```ts
 export function syntaxKindToName(kind: ts.SyntaxKind) {
     return (<any>ts).SyntaxKind[kind];
 }
 ```
-

docs/compiler/binder-container.md

@@ -1,6 +1,6 @@
 ### Container
 
-An AST node can be a container. This determines the kinds of `SymbolTables` the Node and associated Symbol will have. Container is an abstract concept (i.e. has no associated data structure). The concept is driven by a few things, one being the `ContainerFlags` enum. The function `getContainerFlags` (in `binder.ts`) drives this flag and is presented below: 
+An AST node can be a container. This determines the kinds of `SymbolTables` the Node and associated Symbol will have. Container is an abstract concept (i.e. has no associated data structure). The concept is driven by a few things, one being the `ContainerFlags` enum. The function `getContainerFlags` (in `binder.ts`) drives this flag and is presented below:
 
 ```ts
 function getContainerFlags(node: Node): ContainerFlags {
@@ -62,7 +62,7 @@ function getContainerFlags(node: Node): ContainerFlags {
 }
 ```
 
-It is *only* invoked from the binder's `bindChildren` function which sets up a node as a `container` and/or a `blockScopedContainer` depending upon the evaluation of the `getContainerFlags` function. The function `bindChildren` is presented below: 
+It is *only* invoked from the binder's `bindChildren` function which sets up a node as a `container` and/or a `blockScopedContainer` depending upon the evaluation of the `getContainerFlags` function. The function `bindChildren` is presented below:
 
 ```ts
 // All container nodes are kept on a linked list in declaration order. This list is used by
@@ -121,4 +121,3 @@ function bindChildren(node: Node) {
 ```
 
 As you might recall from section on binder functions : `bindChildren` is called from the `bind` function. So we have the recursive bindig setup : `bind` calls `bindChildren` calls `bind` for each child.
-

docs/compiler/binder-declarations.md

@@ -1,7 +1,7 @@
 ### Symbols and Declarations
-Linking between a `node` and a `symbol` is performed by a few functions. One function that is used to bind the `SourceFile` node to the source file Symbol (in case of an external module) is the `addDeclarationToSymbol` function 
+Linking between a `node` and a `symbol` is performed by a few functions. One function that is used to bind the `SourceFile` node to the source file Symbol (in case of an external module) is the `addDeclarationToSymbol` function
 
-Note : the `Symbol` for an external module source file is setup as `flags : SymbolFlags.ValueModule` and `name: '"' + removeFileExtension(file.fileName) + '"'`). 
+Note : the `Symbol` for an external module source file is setup as `flags : SymbolFlags.ValueModule` and `name: '"' + removeFileExtension(file.fileName) + '"'`).
 
 ```ts
 function addDeclarationToSymbol(symbol: Symbol, node: Declaration, symbolFlags: SymbolFlags) {
@@ -28,8 +28,8 @@ function addDeclarationToSymbol(symbol: Symbol, node: Declaration, symbolFlags:
 }
 ```
 
-The important linking portions: 
-* creates a link to the Symbol from the AST node (`node.symbol`). 
+The important linking portions:
+* creates a link to the Symbol from the AST node (`node.symbol`).
 * add the node as *one of* the declarations of the Symbol (`symbol.declarations`).
 
 #### Declaration

docs/compiler/binder-diagnostics.md

@@ -1,8 +1,8 @@
 ### Binder Error Reporting
 
-Binding errors are added to the sourceFile's list of `bindDiagnostics`. 
+Binding errors are added to the sourceFile's list of `bindDiagnostics`.
 
-An example error detected during binding is the use of `eval` or `arguments` as a variable name in `use strict` scenario. The relevant code is presented in its entirety below (`checkStrictModeEvalOrArguments` is called from multiple places, call stacks originating from `bindWorker` which calls different functions for different node `SyntaxKind`): 
+An example error detected during binding is the use of `eval` or `arguments` as a variable name in `use strict` scenario. The relevant code is presented in its entirety below (`checkStrictModeEvalOrArguments` is called from multiple places, call stacks originating from `bindWorker` which calls different functions for different node `SyntaxKind`):
 
 ```ts
 function checkStrictModeEvalOrArguments(contextNode: Node, name: Node) {
@@ -36,4 +36,4 @@ function getStrictModeEvalOrArgumentsMessage(node: Node) {
 
     return Diagnostics.Invalid_use_of_0_in_strict_mode;
 }
-``` 
+```

docs/compiler/binder-functions.md

@@ -6,7 +6,7 @@ Basically checks if the `file.locals` is defined, if not it hands over to (a loc
 
 Note: `locals` is defined on `Node` and is of type `SymbolTable`. Note that `SourceFile` is also a `Node` (in fact a root node in the AST).
 
-TIP: local functions are used heavily within the TypeScript compiler. A local function very likely uses variables from the parent function (captured by closure). In the case of `bind` (a local function within `bindSourceFile`) it (or function it calls) will setup the `symbolCount` and `classifiableNames` among others, that are then stored on the returned `SourceFile`. 
+TIP: local functions are used heavily within the TypeScript compiler. A local function very likely uses variables from the parent function (captured by closure). In the case of `bind` (a local function within `bindSourceFile`) it (or function it calls) will setup the `symbolCount` and `classifiableNames` among others, that are then stored on the returned `SourceFile`.
 
 #### `bind`
 Bind takes any `Node` (not just `SourceFile`). First thing it does is assign the `node.parent` (if `parent` variable has been setup ... which again is something the binder does during its processing within the `bindChildren` function), then hands off to `bindWorker` which does the *heavy* lifting. Finally it calls `bindChildren` (a function that simply stores the binder state e.g. current `parent` within its function local vars, then calls `bind` on each child, and then restores the binder state). Now lets look at `bindWorker` which is the more interesting function.
@@ -15,7 +15,7 @@ Bind takes any `Node` (not just `SourceFile`). First thing it does is assign the
 This function switches on `node.kind` (of type `SyntaxKind`) and delegates work to the appropriate `bindFoo` function (also defined within `binder.ts`). For example if the `node` is a `SourceFile` it calls (eventually and only if its an external file module) `bindAnonymousDeclaration`
 
 #### `bindFoo` functions
-There are few pattern common to `bindFoo` functions as well as some utility functions that these use. One function that is almost always used is the `createSymbol` function. It is presented in its entirety below: 
+There are few pattern common to `bindFoo` functions as well as some utility functions that these use. One function that is almost always used is the `createSymbol` function. It is presented in its entirety below:
 
 ```ts
 function createSymbol(flags: SymbolFlags, name: string): Symbol {

docs/compiler/binder-symbolflags.md

@@ -2,4 +2,4 @@
 Symbols have `SymbolFlags`. Below we eplain the meaning of the important ones
 
 #### ValueModule
-`ValueModule // Instantiated module` is the SymbolFlag used for `SourceFile` if it an external module.
+`ValueModule // Instantiated module` is the SymbolFlag used for `SourceFile` if it an external module.

docs/compiler/checker-global.md

@@ -10,4 +10,4 @@ forEach(host.getSourceFiles(), file => {
 });
 ```
 
-Which basically merges all the `global` symbols into the `let globals: SymbolTable = {};` (in `createTypeChecker`) SymbolTable. `mergeSymbolTable` primarily calls `mergeSymbol`. 
+Which basically merges all the `global` symbols into the `let globals: SymbolTable = {};` (in `createTypeChecker`) SymbolTable. `mergeSymbolTable` primarily calls `mergeSymbol`.

docs/compiler/checker.md

@@ -16,19 +16,18 @@ program.getTypeChecker ->
 ### Association with Emitter
 True type checking happens once a call is made to `getDiagnostics`. This function is called e.g. once a request is made to `Program.emit`, in which case the checker returns an `EmitResolver` (progarm calls the checkers `getEmitResolver` function) which is just a set of functions local to `createTypeChecker`. We will mention this again when we look at the emitter.
 
-Here is the call stack right down to `checkSourceFile` (a function local to `createTypeChecker`). 
+Here is the call stack right down to `checkSourceFile` (a function local to `createTypeChecker`).
 
 ```
-program.emit -> 
-    emitWorker (program local) -> 
+program.emit ->
+    emitWorker (program local) ->
         createTypeChecker.getEmitResolver ->
             // First call the following functions local to createTypeChecker
-            call getDiagnostics -> 
-                getDiagnosticsWorker -> 
+            call getDiagnostics ->
+                getDiagnosticsWorker ->
                     checkSourceFile
-            
+
             // then
-            return resolver 
+            return resolver
             (already initialized in createTypeChecker using a call to local createResolver())
 ```
-

docs/compiler/contributing.md

@@ -58,4 +58,4 @@ Test can be created by adding a new file `yourtest.ts` to `tests/cases/compiler`
 
 Run all of these in isolation using `jake runtests tests=compiler`, or just your new file using `jake runtests tests=compiler/yourtest`
 
-I will even often do `jake runtests tests=compiler/yourtest || jake baseline-accept[soft]` and get the diff in `git`.
+I will even often do `jake runtests tests=compiler/yourtest || jake baseline-accept[soft]` and get the diff in `git`.

docs/compiler/emitter.md

@@ -7,11 +7,11 @@ There are two `emitters` provided with the TypeScript compiler:
 We will look at `emitter.ts` in this section.
 
 ### Usage by `program`
-Program provides an `emit` function. This function primarily delegates to `emitFiles` function in `emitter.ts`. Here is the call stack: 
+Program provides an `emit` function. This function primarily delegates to `emitFiles` function in `emitter.ts`. Here is the call stack:
 
 ```
-Program.emit -> 
+Program.emit ->
     `emitWorker` (local in program.ts createProgram) ->
         `emitFiles` (function in emitter.ts)
 ```
-One thing that the `emitWorker` provides to the emitter (via an argument to `emitFiles`) is an `EmitResolver`. `EmitResolver` is provided by the program's TypeChecker, basically it a subset of *local* functions from `createChecker`.
+One thing that the `emitWorker` provides to the emitter (via an argument to `emitFiles`) is an `EmitResolver`. `EmitResolver` is provided by the program's TypeChecker, basically it a subset of *local* functions from `createChecker`.