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;
 }
-``` 
+```