Merge branch 'master' into transitiveExports

.gitignore

@@ -21,6 +21,7 @@ tests/services/baselines/local/*
 tests/baselines/prototyping/local/*
 tests/baselines/rwc/*
 tests/baselines/test262/*
+tests/baselines/local/projectOutput/*
 tests/services/baselines/prototyping/local/*
 tests/services/browser/typescriptServices.js
 scripts/processDiagnosticMessages.d.ts

Jakefile

@@ -111,6 +111,7 @@ var definitionsRoots = [
     "compiler/parser.d.ts",
     "compiler/checker.d.ts",
     "compiler/program.d.ts",
+    "compiler/commandLineParser.d.ts",
     "services/services.d.ts",
 ];
 
@@ -222,15 +223,17 @@ function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, noOu
         var dir = useBuiltCompiler ? builtLocalDirectory : LKGDirectory;
         var options = "--module commonjs -noImplicitAny";
 
-        if (!keepComments) {
-            options += " -removeComments";
+        // Keep comments when specifically requested
+        // or when in debug mode.
+        if (!(keepComments || useDebugMode)) {
+            options += " --removeComments";
         }
 
         if (generateDeclarations) {
             options += " --declaration";
         }
 
-        if (useDebugMode || preserveConstEnums) {
+        if (preserveConstEnums || useDebugMode) {
             options += " --preserveConstEnums";
         }
 
@@ -254,8 +257,6 @@ function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, noOu
             options += " --stripInternal"
         }
 
-        options += " --cacheDownlevelForOfLength --preserveNewLines";
-
         var cmd = host + " " + dir + compilerFilename + " " + options + " ";
         cmd = cmd + sources.join(" ");
         console.log(cmd + "\n");

bin/lib.core.d.ts

@@ -1170,3 +1170,17 @@ interface ArrayConstructor {
 }
 
 declare var Array: ArrayConstructor;
+
+interface TypedPropertyDescriptor<T> {
+    enumerable?: boolean;
+    configurable?: boolean;
+    writable?: boolean;
+    value?: T;
+    get?: () => T;
+    set?: (value: T) => void;
+}
+
+declare type ClassDecorator = <TFunction extends Function>(target: TFunction) => TFunction | void;
+declare type PropertyDecorator = (target: Object, propertyKey: string | symbol) => void;
+declare type MethodDecorator = <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
+declare type ParameterDecorator = (target: Function, propertyKey: string | symbol, parameterIndex: number) => void;

bin/lib.core.es6.d.ts

@@ -1170,6 +1170,20 @@ interface ArrayConstructor {
 }
 
 declare var Array: ArrayConstructor;
+
+interface TypedPropertyDescriptor<T> {
+    enumerable?: boolean;
+    configurable?: boolean;
+    writable?: boolean;
+    value?: T;
+    get?: () => T;
+    set?: (value: T) => void;
+}
+
+declare type ClassDecorator = <TFunction extends Function>(target: TFunction) => TFunction | void;
+declare type PropertyDecorator = (target: Object, propertyKey: string | symbol) => void;
+declare type MethodDecorator = <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
+declare type ParameterDecorator = (target: Function, propertyKey: string | symbol, parameterIndex: number) => void;
 declare type PropertyKey = string | number | symbol;
 
 interface Symbol {

bin/lib.d.ts

@@ -1171,6 +1171,20 @@ interface ArrayConstructor {
 
 declare var Array: ArrayConstructor;
 
+interface TypedPropertyDescriptor<T> {
+    enumerable?: boolean;
+    configurable?: boolean;
+    writable?: boolean;
+    value?: T;
+    get?: () => T;
+    set?: (value: T) => void;
+}
+
+declare type ClassDecorator = <TFunction extends Function>(target: TFunction) => TFunction | void;
+declare type PropertyDecorator = (target: Object, propertyKey: string | symbol) => void;
+declare type MethodDecorator = <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
+declare type ParameterDecorator = (target: Function, propertyKey: string | symbol, parameterIndex: number) => void;
+
 /////////////////////////////
 /// IE10 ECMAScript Extensions
 /////////////////////////////
@@ -14209,7 +14223,11 @@ declare function importScripts(...urls: string[]): void;
 /// Windows Script Host APIS
 /////////////////////////////
 
-declare var ActiveXObject: { new (s: string): any; };
+
+interface ActiveXObject {
+    new (s: string): any;
+}
+declare var ActiveXObject: ActiveXObject;
 
 interface ITextWriter {
     Write(s: string): void;
@@ -14217,11 +14235,157 @@ interface ITextWriter {
     Close(): void;
 }
 
-declare var WScript: {
-    Echo(s: any): void;
-    StdErr: ITextWriter;
-    StdOut: ITextWriter;
-    Arguments: { length: number; Item(n: number): string; };
-    ScriptFullName: string;
-    Quit(exitCode?: number): number;
+interface TextStreamBase {
+    /**
+     * The column number of the current character position in an input stream.
+     */
+    Column: number;
+    /**
+     * The current line number in an input stream.
+     */
+    Line: number;
+    /**
+     * Closes a text stream.
+     * It is not necessary to close standard streams; they close automatically when the process ends. If you close a standard stream, be aware that any other pointers to that standard stream become invalid.
+     */
+    Close(): void;
 }
+
+interface TextStreamWriter extends TextStreamBase {
+    /**
+     * Sends a string to an output stream.
+     */
+    Write(s: string): void;
+    /**
+     * Sends a specified number of blank lines (newline characters) to an output stream.
+     */
+    WriteBlankLines(intLines: number): void;
+    /**
+     * Sends a string followed by a newline character to an output stream.
+     */
+    WriteLine(s: string): void;
+}
+
+interface TextStreamReader extends TextStreamBase {
+    /**
+     * Returns a specified number of characters from an input stream, beginning at the current pointer position.
+     * Does not return until the ENTER key is pressed.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    Read(characters: number): string;
+    /**
+     * Returns all characters from an input stream.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    ReadAll(): string;
+    /**
+     * Returns an entire line from an input stream.
+     * Although this method extracts the newline character, it does not add it to the returned string.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    ReadLine(): string;
+    /**
+     * Skips a specified number of characters when reading from an input text stream.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     * @param characters Positive number of characters to skip forward. (Backward skipping is not supported.)
+     */
+    Skip(characters: number): void;
+    /**
+     * Skips the next line when reading from an input text stream.
+     * Can only be used on a stream in reading mode, not writing or appending mode.
+     */
+    SkipLine(): void;
+    /**
+     * Indicates whether the stream pointer position is at the end of a line.
+     */
+    AtEndOfLine: boolean;
+    /**
+     * Indicates whether the stream pointer position is at the end of a stream.
+     */
+    AtEndOfStream: boolean;
+}
+
+declare var WScript: {
+    /**
+    * Outputs text to either a message box (under WScript.exe) or the command console window followed by a newline (under CScript.ext).
+    */
+    Echo(s: any): void;
+    /**
+     * Exposes the write-only error output stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdErr: TextStreamWriter;
+    /**
+     * Exposes the write-only output stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdOut: TextStreamWriter;
+    Arguments: { length: number; Item(n: number): string; };
+    /**
+     *  The full path of the currently running script.
+     */
+    ScriptFullName: string;
+    /**
+     * Forces the script to stop immediately, with an optional exit code.
+     */
+    Quit(exitCode?: number): number;
+    /**
+     * The Windows Script Host build version number.
+     */
+    BuildVersion: number;
+    /**
+     * Fully qualified path of the host executable.
+     */
+    FullName: string;
+    /**
+     * Gets/sets the script mode - interactive(true) or batch(false).
+     */
+    Interactive: boolean;
+    /**
+     * The name of the host executable (WScript.exe or CScript.exe).
+     */
+    Name: string;
+    /**
+     * Path of the directory containing the host executable.
+     */
+    Path: string;
+    /**
+     * The filename of the currently running script.
+     */
+    ScriptName: string;
+    /**
+     * Exposes the read-only input stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdIn: TextStreamReader;
+    /**
+     * Windows Script Host version
+     */
+    Version: string;
+    /**
+     * Connects a COM object's event sources to functions named with a given prefix, in the form prefix_event.
+     */
+    ConnectObject(objEventSource: any, strPrefix: string): void;
+    /**
+     * Creates a COM object.
+     * @param strProgiID
+     * @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
+     */
+    CreateObject(strProgID: string, strPrefix?: string): any;
+    /**
+     * Disconnects a COM object from its event sources.
+     */
+    DisconnectObject(obj: any): void;
+    /**
+     * Retrieves an existing object with the specified ProgID from memory, or creates a new one from a file.
+     * @param strPathname Fully qualified path to the file containing the object persisted to disk. For objects in memory, pass a zero-length string.
+     * @param strProgID
+     * @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
+     */
+    GetObject(strPathname: string, strProgID?: string, strPrefix?: string): any;
+    /**
+     * Suspends script execution for a specified length of time, then continues execution.
+     * @param intTime Interval (in milliseconds) to suspend script execution.
+     */
+    Sleep(intTime: number): void;
+};

bin/lib.es6.d.ts

@@ -1170,6 +1170,20 @@ interface ArrayConstructor {
 }
 
 declare var Array: ArrayConstructor;
+
+interface TypedPropertyDescriptor<T> {
+    enumerable?: boolean;
+    configurable?: boolean;
+    writable?: boolean;
+    value?: T;
+    get?: () => T;
+    set?: (value: T) => void;
+}
+
+declare type ClassDecorator = <TFunction extends Function>(target: TFunction) => TFunction | void;
+declare type PropertyDecorator = (target: Object, propertyKey: string | symbol) => void;
+declare type MethodDecorator = <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
+declare type ParameterDecorator = (target: Function, propertyKey: string | symbol, parameterIndex: number) => void;
 declare type PropertyKey = string | number | symbol;
 
 interface Symbol {
@@ -17191,7 +17205,11 @@ declare function importScripts(...urls: string[]): void;
 /// Windows Script Host APIS
 /////////////////////////////
 
-declare var ActiveXObject: { new (s: string): any; };
+
+interface ActiveXObject {
+    new (s: string): any;
+}
+declare var ActiveXObject: ActiveXObject;
 
 interface ITextWriter {
     Write(s: string): void;
@@ -17199,11 +17217,157 @@ interface ITextWriter {
     Close(): void;
 }
 
-declare var WScript: {
-    Echo(s: any): void;
-    StdErr: ITextWriter;
-    StdOut: ITextWriter;
-    Arguments: { length: number; Item(n: number): string; };
-    ScriptFullName: string;
-    Quit(exitCode?: number): number;
+interface TextStreamBase {
+    /**
+     * The column number of the current character position in an input stream.
+     */
+    Column: number;
+    /**
+     * The current line number in an input stream.
+     */
+    Line: number;
+    /**
+     * Closes a text stream.
+     * It is not necessary to close standard streams; they close automatically when the process ends. If you close a standard stream, be aware that any other pointers to that standard stream become invalid.
+     */
+    Close(): void;
 }
+
+interface TextStreamWriter extends TextStreamBase {
+    /**
+     * Sends a string to an output stream.
+     */
+    Write(s: string): void;
+    /**
+     * Sends a specified number of blank lines (newline characters) to an output stream.
+     */
+    WriteBlankLines(intLines: number): void;
+    /**
+     * Sends a string followed by a newline character to an output stream.
+     */
+    WriteLine(s: string): void;
+}
+
+interface TextStreamReader extends TextStreamBase {
+    /**
+     * Returns a specified number of characters from an input stream, beginning at the current pointer position.
+     * Does not return until the ENTER key is pressed.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    Read(characters: number): string;
+    /**
+     * Returns all characters from an input stream.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    ReadAll(): string;
+    /**
+     * Returns an entire line from an input stream.
+     * Although this method extracts the newline character, it does not add it to the returned string.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    ReadLine(): string;
+    /**
+     * Skips a specified number of characters when reading from an input text stream.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     * @param characters Positive number of characters to skip forward. (Backward skipping is not supported.)
+     */
+    Skip(characters: number): void;
+    /**
+     * Skips the next line when reading from an input text stream.
+     * Can only be used on a stream in reading mode, not writing or appending mode.
+     */
+    SkipLine(): void;
+    /**
+     * Indicates whether the stream pointer position is at the end of a line.
+     */
+    AtEndOfLine: boolean;
+    /**
+     * Indicates whether the stream pointer position is at the end of a stream.
+     */
+    AtEndOfStream: boolean;
+}
+
+declare var WScript: {
+    /**
+    * Outputs text to either a message box (under WScript.exe) or the command console window followed by a newline (under CScript.ext).
+    */
+    Echo(s: any): void;
+    /**
+     * Exposes the write-only error output stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdErr: TextStreamWriter;
+    /**
+     * Exposes the write-only output stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdOut: TextStreamWriter;
+    Arguments: { length: number; Item(n: number): string; };
+    /**
+     *  The full path of the currently running script.
+     */
+    ScriptFullName: string;
+    /**
+     * Forces the script to stop immediately, with an optional exit code.
+     */
+    Quit(exitCode?: number): number;
+    /**
+     * The Windows Script Host build version number.
+     */
+    BuildVersion: number;
+    /**
+     * Fully qualified path of the host executable.
+     */
+    FullName: string;
+    /**
+     * Gets/sets the script mode - interactive(true) or batch(false).
+     */
+    Interactive: boolean;
+    /**
+     * The name of the host executable (WScript.exe or CScript.exe).
+     */
+    Name: string;
+    /**
+     * Path of the directory containing the host executable.
+     */
+    Path: string;
+    /**
+     * The filename of the currently running script.
+     */
+    ScriptName: string;
+    /**
+     * Exposes the read-only input stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdIn: TextStreamReader;
+    /**
+     * Windows Script Host version
+     */
+    Version: string;
+    /**
+     * Connects a COM object's event sources to functions named with a given prefix, in the form prefix_event.
+     */
+    ConnectObject(objEventSource: any, strPrefix: string): void;
+    /**
+     * Creates a COM object.
+     * @param strProgiID
+     * @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
+     */
+    CreateObject(strProgID: string, strPrefix?: string): any;
+    /**
+     * Disconnects a COM object from its event sources.
+     */
+    DisconnectObject(obj: any): void;
+    /**
+     * Retrieves an existing object with the specified ProgID from memory, or creates a new one from a file.
+     * @param strPathname Fully qualified path to the file containing the object persisted to disk. For objects in memory, pass a zero-length string.
+     * @param strProgID
+     * @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
+     */
+    GetObject(strPathname: string, strProgID?: string, strPrefix?: string): any;
+    /**
+     * Suspends script execution for a specified length of time, then continues execution.
+     * @param intTime Interval (in milliseconds) to suspend script execution.
+     */
+    Sleep(intTime: number): void;
+};

bin/lib.scriptHost.d.ts

@@ -20,7 +20,11 @@ and limitations under the License.
 /// Windows Script Host APIS
 /////////////////////////////
 
-declare var ActiveXObject: { new (s: string): any; };
+
+interface ActiveXObject {
+    new (s: string): any;
+}
+declare var ActiveXObject: ActiveXObject;
 
 interface ITextWriter {
     Write(s: string): void;
@@ -28,11 +32,157 @@ interface ITextWriter {
     Close(): void;
 }
 
-declare var WScript: {
-    Echo(s: any): void;
-    StdErr: ITextWriter;
-    StdOut: ITextWriter;
-    Arguments: { length: number; Item(n: number): string; };
-    ScriptFullName: string;
-    Quit(exitCode?: number): number;
+interface TextStreamBase {
+    /**
+     * The column number of the current character position in an input stream.
+     */
+    Column: number;
+    /**
+     * The current line number in an input stream.
+     */
+    Line: number;
+    /**
+     * Closes a text stream.
+     * It is not necessary to close standard streams; they close automatically when the process ends. If you close a standard stream, be aware that any other pointers to that standard stream become invalid.
+     */
+    Close(): void;
 }
+
+interface TextStreamWriter extends TextStreamBase {
+    /**
+     * Sends a string to an output stream.
+     */
+    Write(s: string): void;
+    /**
+     * Sends a specified number of blank lines (newline characters) to an output stream.
+     */
+    WriteBlankLines(intLines: number): void;
+    /**
+     * Sends a string followed by a newline character to an output stream.
+     */
+    WriteLine(s: string): void;
+}
+
+interface TextStreamReader extends TextStreamBase {
+    /**
+     * Returns a specified number of characters from an input stream, beginning at the current pointer position.
+     * Does not return until the ENTER key is pressed.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    Read(characters: number): string;
+    /**
+     * Returns all characters from an input stream.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    ReadAll(): string;
+    /**
+     * Returns an entire line from an input stream.
+     * Although this method extracts the newline character, it does not add it to the returned string.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    ReadLine(): string;
+    /**
+     * Skips a specified number of characters when reading from an input text stream.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     * @param characters Positive number of characters to skip forward. (Backward skipping is not supported.)
+     */
+    Skip(characters: number): void;
+    /**
+     * Skips the next line when reading from an input text stream.
+     * Can only be used on a stream in reading mode, not writing or appending mode.
+     */
+    SkipLine(): void;
+    /**
+     * Indicates whether the stream pointer position is at the end of a line.
+     */
+    AtEndOfLine: boolean;
+    /**
+     * Indicates whether the stream pointer position is at the end of a stream.
+     */
+    AtEndOfStream: boolean;
+}
+
+declare var WScript: {
+    /**
+    * Outputs text to either a message box (under WScript.exe) or the command console window followed by a newline (under CScript.ext).
+    */
+    Echo(s: any): void;
+    /**
+     * Exposes the write-only error output stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdErr: TextStreamWriter;
+    /**
+     * Exposes the write-only output stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdOut: TextStreamWriter;
+    Arguments: { length: number; Item(n: number): string; };
+    /**
+     *  The full path of the currently running script.
+     */
+    ScriptFullName: string;
+    /**
+     * Forces the script to stop immediately, with an optional exit code.
+     */
+    Quit(exitCode?: number): number;
+    /**
+     * The Windows Script Host build version number.
+     */
+    BuildVersion: number;
+    /**
+     * Fully qualified path of the host executable.
+     */
+    FullName: string;
+    /**
+     * Gets/sets the script mode - interactive(true) or batch(false).
+     */
+    Interactive: boolean;
+    /**
+     * The name of the host executable (WScript.exe or CScript.exe).
+     */
+    Name: string;
+    /**
+     * Path of the directory containing the host executable.
+     */
+    Path: string;
+    /**
+     * The filename of the currently running script.
+     */
+    ScriptName: string;
+    /**
+     * Exposes the read-only input stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdIn: TextStreamReader;
+    /**
+     * Windows Script Host version
+     */
+    Version: string;
+    /**
+     * Connects a COM object's event sources to functions named with a given prefix, in the form prefix_event.
+     */
+    ConnectObject(objEventSource: any, strPrefix: string): void;
+    /**
+     * Creates a COM object.
+     * @param strProgiID
+     * @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
+     */
+    CreateObject(strProgID: string, strPrefix?: string): any;
+    /**
+     * Disconnects a COM object from its event sources.
+     */
+    DisconnectObject(obj: any): void;
+    /**
+     * Retrieves an existing object with the specified ProgID from memory, or creates a new one from a file.
+     * @param strPathname Fully qualified path to the file containing the object persisted to disk. For objects in memory, pass a zero-length string.
+     * @param strProgID
+     * @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
+     */
+    GetObject(strPathname: string, strProgID?: string, strPrefix?: string): any;
+    /**
+     * Suspends script execution for a specified length of time, then continues execution.
+     * @param intTime Interval (in milliseconds) to suspend script execution.
+     */
+    Sleep(intTime: number): void;
+};

bin/typescript.d.ts

@@ -74,192 +74,198 @@ declare module "typescript" {
         BarBarToken = 49,
         QuestionToken = 50,
         ColonToken = 51,
-        EqualsToken = 52,
-        PlusEqualsToken = 53,
-        MinusEqualsToken = 54,
-        AsteriskEqualsToken = 55,
-        SlashEqualsToken = 56,
-        PercentEqualsToken = 57,
-        LessThanLessThanEqualsToken = 58,
-        GreaterThanGreaterThanEqualsToken = 59,
-        GreaterThanGreaterThanGreaterThanEqualsToken = 60,
-        AmpersandEqualsToken = 61,
-        BarEqualsToken = 62,
-        CaretEqualsToken = 63,
-        Identifier = 64,
-        BreakKeyword = 65,
-        CaseKeyword = 66,
-        CatchKeyword = 67,
-        ClassKeyword = 68,
-        ConstKeyword = 69,
-        ContinueKeyword = 70,
-        DebuggerKeyword = 71,
-        DefaultKeyword = 72,
-        DeleteKeyword = 73,
-        DoKeyword = 74,
-        ElseKeyword = 75,
-        EnumKeyword = 76,
-        ExportKeyword = 77,
-        ExtendsKeyword = 78,
-        FalseKeyword = 79,
-        FinallyKeyword = 80,
-        ForKeyword = 81,
-        FunctionKeyword = 82,
-        IfKeyword = 83,
-        ImportKeyword = 84,
-        InKeyword = 85,
-        InstanceOfKeyword = 86,
-        NewKeyword = 87,
-        NullKeyword = 88,
-        ReturnKeyword = 89,
-        SuperKeyword = 90,
-        SwitchKeyword = 91,
-        ThisKeyword = 92,
-        ThrowKeyword = 93,
-        TrueKeyword = 94,
-        TryKeyword = 95,
-        TypeOfKeyword = 96,
-        VarKeyword = 97,
-        VoidKeyword = 98,
-        WhileKeyword = 99,
-        WithKeyword = 100,
-        AsKeyword = 101,
-        ImplementsKeyword = 102,
-        InterfaceKeyword = 103,
-        LetKeyword = 104,
-        PackageKeyword = 105,
-        PrivateKeyword = 106,
-        ProtectedKeyword = 107,
-        PublicKeyword = 108,
-        StaticKeyword = 109,
-        YieldKeyword = 110,
-        AnyKeyword = 111,
-        BooleanKeyword = 112,
-        ConstructorKeyword = 113,
-        DeclareKeyword = 114,
-        GetKeyword = 115,
-        ModuleKeyword = 116,
-        RequireKeyword = 117,
-        NumberKeyword = 118,
-        SetKeyword = 119,
-        StringKeyword = 120,
-        SymbolKeyword = 121,
-        TypeKeyword = 122,
-        FromKeyword = 123,
-        OfKeyword = 124,
-        QualifiedName = 125,
-        ComputedPropertyName = 126,
-        TypeParameter = 127,
-        Parameter = 128,
-        PropertySignature = 129,
-        PropertyDeclaration = 130,
-        MethodSignature = 131,
-        MethodDeclaration = 132,
-        Constructor = 133,
-        GetAccessor = 134,
-        SetAccessor = 135,
-        CallSignature = 136,
-        ConstructSignature = 137,
-        IndexSignature = 138,
-        TypeReference = 139,
-        FunctionType = 140,
-        ConstructorType = 141,
-        TypeQuery = 142,
-        TypeLiteral = 143,
-        ArrayType = 144,
-        TupleType = 145,
-        UnionType = 146,
-        ParenthesizedType = 147,
-        ObjectBindingPattern = 148,
-        ArrayBindingPattern = 149,
-        BindingElement = 150,
-        ArrayLiteralExpression = 151,
-        ObjectLiteralExpression = 152,
-        PropertyAccessExpression = 153,
-        ElementAccessExpression = 154,
-        CallExpression = 155,
-        NewExpression = 156,
-        TaggedTemplateExpression = 157,
-        TypeAssertionExpression = 158,
-        ParenthesizedExpression = 159,
-        FunctionExpression = 160,
-        ArrowFunction = 161,
-        DeleteExpression = 162,
-        TypeOfExpression = 163,
-        VoidExpression = 164,
-        PrefixUnaryExpression = 165,
-        PostfixUnaryExpression = 166,
-        BinaryExpression = 167,
-        ConditionalExpression = 168,
-        TemplateExpression = 169,
-        YieldExpression = 170,
-        SpreadElementExpression = 171,
-        OmittedExpression = 172,
-        TemplateSpan = 173,
-        Block = 174,
-        VariableStatement = 175,
-        EmptyStatement = 176,
-        ExpressionStatement = 177,
-        IfStatement = 178,
-        DoStatement = 179,
-        WhileStatement = 180,
-        ForStatement = 181,
-        ForInStatement = 182,
-        ForOfStatement = 183,
-        ContinueStatement = 184,
-        BreakStatement = 185,
-        ReturnStatement = 186,
-        WithStatement = 187,
-        SwitchStatement = 188,
-        LabeledStatement = 189,
-        ThrowStatement = 190,
-        TryStatement = 191,
-        DebuggerStatement = 192,
-        VariableDeclaration = 193,
-        VariableDeclarationList = 194,
-        FunctionDeclaration = 195,
-        ClassDeclaration = 196,
-        InterfaceDeclaration = 197,
-        TypeAliasDeclaration = 198,
-        EnumDeclaration = 199,
-        ModuleDeclaration = 200,
-        ModuleBlock = 201,
-        CaseBlock = 202,
-        ImportEqualsDeclaration = 203,
-        ImportDeclaration = 204,
-        ImportClause = 205,
-        NamespaceImport = 206,
-        NamedImports = 207,
-        ImportSpecifier = 208,
-        ExportAssignment = 209,
-        ExportDeclaration = 210,
-        NamedExports = 211,
-        ExportSpecifier = 212,
-        ExternalModuleReference = 213,
-        CaseClause = 214,
-        DefaultClause = 215,
-        HeritageClause = 216,
-        CatchClause = 217,
-        PropertyAssignment = 218,
-        ShorthandPropertyAssignment = 219,
-        EnumMember = 220,
-        SourceFile = 221,
-        SyntaxList = 222,
-        Count = 223,
-        FirstAssignment = 52,
-        LastAssignment = 63,
-        FirstReservedWord = 65,
-        LastReservedWord = 100,
-        FirstKeyword = 65,
-        LastKeyword = 124,
-        FirstFutureReservedWord = 102,
-        LastFutureReservedWord = 110,
-        FirstTypeNode = 139,
-        LastTypeNode = 147,
+        AtToken = 52,
+        EqualsToken = 53,
+        PlusEqualsToken = 54,
+        MinusEqualsToken = 55,
+        AsteriskEqualsToken = 56,
+        SlashEqualsToken = 57,
+        PercentEqualsToken = 58,
+        LessThanLessThanEqualsToken = 59,
+        GreaterThanGreaterThanEqualsToken = 60,
+        GreaterThanGreaterThanGreaterThanEqualsToken = 61,
+        AmpersandEqualsToken = 62,
+        BarEqualsToken = 63,
+        CaretEqualsToken = 64,
+        Identifier = 65,
+        BreakKeyword = 66,
+        CaseKeyword = 67,
+        CatchKeyword = 68,
+        ClassKeyword = 69,
+        ConstKeyword = 70,
+        ContinueKeyword = 71,
+        DebuggerKeyword = 72,
+        DefaultKeyword = 73,
+        DeleteKeyword = 74,
+        DoKeyword = 75,
+        ElseKeyword = 76,
+        EnumKeyword = 77,
+        ExportKeyword = 78,
+        ExtendsKeyword = 79,
+        FalseKeyword = 80,
+        FinallyKeyword = 81,
+        ForKeyword = 82,
+        FunctionKeyword = 83,
+        IfKeyword = 84,
+        ImportKeyword = 85,
+        InKeyword = 86,
+        InstanceOfKeyword = 87,
+        NewKeyword = 88,
+        NullKeyword = 89,
+        ReturnKeyword = 90,
+        SuperKeyword = 91,
+        SwitchKeyword = 92,
+        ThisKeyword = 93,
+        ThrowKeyword = 94,
+        TrueKeyword = 95,
+        TryKeyword = 96,
+        TypeOfKeyword = 97,
+        VarKeyword = 98,
+        VoidKeyword = 99,
+        WhileKeyword = 100,
+        WithKeyword = 101,
+        AsKeyword = 102,
+        ImplementsKeyword = 103,
+        InterfaceKeyword = 104,
+        LetKeyword = 105,
+        PackageKeyword = 106,
+        PrivateKeyword = 107,
+        ProtectedKeyword = 108,
+        PublicKeyword = 109,
+        StaticKeyword = 110,
+        YieldKeyword = 111,
+        AnyKeyword = 112,
+        BooleanKeyword = 113,
+        ConstructorKeyword = 114,
+        DeclareKeyword = 115,
+        GetKeyword = 116,
+        ModuleKeyword = 117,
+        RequireKeyword = 118,
+        NumberKeyword = 119,
+        SetKeyword = 120,
+        StringKeyword = 121,
+        SymbolKeyword = 122,
+        TypeKeyword = 123,
+        FromKeyword = 124,
+        OfKeyword = 125,
+        QualifiedName = 126,
+        ComputedPropertyName = 127,
+        TypeParameter = 128,
+        Parameter = 129,
+        Decorator = 130,
+        PropertySignature = 131,
+        PropertyDeclaration = 132,
+        MethodSignature = 133,
+        MethodDeclaration = 134,
+        Constructor = 135,
+        GetAccessor = 136,
+        SetAccessor = 137,
+        CallSignature = 138,
+        ConstructSignature = 139,
+        IndexSignature = 140,
+        TypeReference = 141,
+        FunctionType = 142,
+        ConstructorType = 143,
+        TypeQuery = 144,
+        TypeLiteral = 145,
+        ArrayType = 146,
+        TupleType = 147,
+        UnionType = 148,
+        ParenthesizedType = 149,
+        ObjectBindingPattern = 150,
+        ArrayBindingPattern = 151,
+        BindingElement = 152,
+        ArrayLiteralExpression = 153,
+        ObjectLiteralExpression = 154,
+        PropertyAccessExpression = 155,
+        ElementAccessExpression = 156,
+        CallExpression = 157,
+        NewExpression = 158,
+        TaggedTemplateExpression = 159,
+        TypeAssertionExpression = 160,
+        ParenthesizedExpression = 161,
+        FunctionExpression = 162,
+        ArrowFunction = 163,
+        DeleteExpression = 164,
+        TypeOfExpression = 165,
+        VoidExpression = 166,
+        PrefixUnaryExpression = 167,
+        PostfixUnaryExpression = 168,
+        BinaryExpression = 169,
+        ConditionalExpression = 170,
+        TemplateExpression = 171,
+        YieldExpression = 172,
+        SpreadElementExpression = 173,
+        ClassExpression = 174,
+        OmittedExpression = 175,
+        TemplateSpan = 176,
+        HeritageClauseElement = 177,
+        SemicolonClassElement = 178,
+        Block = 179,
+        VariableStatement = 180,
+        EmptyStatement = 181,
+        ExpressionStatement = 182,
+        IfStatement = 183,
+        DoStatement = 184,
+        WhileStatement = 185,
+        ForStatement = 186,
+        ForInStatement = 187,
+        ForOfStatement = 188,
+        ContinueStatement = 189,
+        BreakStatement = 190,
+        ReturnStatement = 191,
+        WithStatement = 192,
+        SwitchStatement = 193,
+        LabeledStatement = 194,
+        ThrowStatement = 195,
+        TryStatement = 196,
+        DebuggerStatement = 197,
+        VariableDeclaration = 198,
+        VariableDeclarationList = 199,
+        FunctionDeclaration = 200,
+        ClassDeclaration = 201,
+        InterfaceDeclaration = 202,
+        TypeAliasDeclaration = 203,
+        EnumDeclaration = 204,
+        ModuleDeclaration = 205,
+        ModuleBlock = 206,
+        CaseBlock = 207,
+        ImportEqualsDeclaration = 208,
+        ImportDeclaration = 209,
+        ImportClause = 210,
+        NamespaceImport = 211,
+        NamedImports = 212,
+        ImportSpecifier = 213,
+        ExportAssignment = 214,
+        ExportDeclaration = 215,
+        NamedExports = 216,
+        ExportSpecifier = 217,
+        MissingDeclaration = 218,
+        ExternalModuleReference = 219,
+        CaseClause = 220,
+        DefaultClause = 221,
+        HeritageClause = 222,
+        CatchClause = 223,
+        PropertyAssignment = 224,
+        ShorthandPropertyAssignment = 225,
+        EnumMember = 226,
+        SourceFile = 227,
+        SyntaxList = 228,
+        Count = 229,
+        FirstAssignment = 53,
+        LastAssignment = 64,
+        FirstReservedWord = 66,
+        LastReservedWord = 101,
+        FirstKeyword = 66,
+        LastKeyword = 125,
+        FirstFutureReservedWord = 103,
+        LastFutureReservedWord = 111,
+        FirstTypeNode = 141,
+        LastTypeNode = 149,
         FirstPunctuation = 14,
-        LastPunctuation = 63,
+        LastPunctuation = 64,
         FirstToken = 0,
-        LastToken = 124,
+        LastToken = 125,
         FirstTriviaToken = 2,
         LastTriviaToken = 6,
         FirstLiteralToken = 7,
@@ -267,8 +273,8 @@ declare module "typescript" {
         FirstTemplateToken = 10,
         LastTemplateToken = 13,
         FirstBinaryOperator = 24,
-        LastBinaryOperator = 63,
-        FirstNode = 125,
+        LastBinaryOperator = 64,
+        FirstNode = 126,
     }
     const enum NodeFlags {
         Export = 1,
@@ -284,6 +290,7 @@ declare module "typescript" {
         Let = 4096,
         Const = 8192,
         OctalLiteral = 16384,
+        ExportContext = 32768,
         Modifier = 499,
         AccessibilityModifier = 112,
         BlockScoped = 12288,
@@ -293,10 +300,11 @@ declare module "typescript" {
         DisallowIn = 2,
         Yield = 4,
         GeneratorParameter = 8,
-        ThisNodeHasError = 16,
-        ParserGeneratedFlags = 31,
-        ThisNodeOrAnySubNodesHasError = 32,
-        HasAggregatedChildData = 64,
+        Decorator = 16,
+        ThisNodeHasError = 32,
+        ParserGeneratedFlags = 63,
+        ThisNodeOrAnySubNodesHasError = 64,
+        HasAggregatedChildData = 128,
     }
     const enum RelationComparisonResult {
         Succeeded = 1,
@@ -307,6 +315,7 @@ declare module "typescript" {
         kind: SyntaxKind;
         flags: NodeFlags;
         parserContextFlags?: ParserContextFlags;
+        decorators?: NodeArray<Decorator>;
         modifiers?: ModifiersArray;
         id?: number;
         parent?: Node;
@@ -337,6 +346,9 @@ declare module "typescript" {
     interface ComputedPropertyName extends Node {
         expression: Expression;
     }
+    interface Decorator extends Node {
+        expression: LeftHandSideExpression;
+    }
     interface TypeParameterDeclaration extends Declaration {
         name: Identifier;
         constraint?: TypeNode;
@@ -423,6 +435,9 @@ declare module "typescript" {
     interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {
         body?: Block;
     }
+    interface SemicolonClassElement extends ClassElement {
+        _semicolonClassElementBrand: any;
+    }
     interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
         _accessorDeclarationBrand: any;
         body: Block;
@@ -516,6 +531,9 @@ declare module "typescript" {
         name?: Identifier;
         body: Block | Expression;
     }
+    interface ArrowFunction extends Expression, FunctionLikeDeclaration {
+        equalsGreaterThanToken: Node;
+    }
     interface LiteralExpression extends PrimaryExpression {
         text: string;
         isUnterminated?: boolean;
@@ -558,6 +576,10 @@ declare module "typescript" {
         typeArguments?: NodeArray<TypeNode>;
         arguments: NodeArray<Expression>;
     }
+    interface HeritageClauseElement extends Node {
+        expression: LeftHandSideExpression;
+        typeArguments?: NodeArray<TypeNode>;
+    }
     interface NewExpression extends CallExpression, PrimaryExpression {
     }
     interface TaggedTemplateExpression extends MemberExpression {
@@ -652,12 +674,16 @@ declare module "typescript" {
     interface ModuleElement extends Node {
         _moduleElementBrand: any;
     }
-    interface ClassDeclaration extends Declaration, ModuleElement {
+    interface ClassLikeDeclaration extends Declaration {
         name?: Identifier;
         typeParameters?: NodeArray<TypeParameterDeclaration>;
         heritageClauses?: NodeArray<HeritageClause>;
         members: NodeArray<ClassElement>;
     }
+    interface ClassDeclaration extends ClassLikeDeclaration, Statement {
+    }
+    interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
+    }
     interface ClassElement extends Declaration {
         _classElementBrand: any;
     }
@@ -669,7 +695,7 @@ declare module "typescript" {
     }
     interface HeritageClause extends Node {
         token: SyntaxKind;
-        types?: NodeArray<TypeReferenceNode>;
+        types?: NodeArray<HeritageClauseElement>;
     }
     interface TypeAliasDeclaration extends Declaration, ModuleElement {
         name: Identifier;
@@ -725,7 +751,8 @@ declare module "typescript" {
     type ExportSpecifier = ImportOrExportSpecifier;
     interface ExportAssignment extends Declaration, ModuleElement {
         isExportEquals?: boolean;
-        expression: Expression;
+        expression?: Expression;
+        type?: TypeNode;
     }
     interface FileReference extends TextRange {
         fileName: string;
@@ -760,14 +787,14 @@ declare module "typescript" {
     interface Program extends ScriptReferenceHost {
         getSourceFiles(): SourceFile[];
         /**
-         * Emits the javascript and declaration files.  If targetSourceFile is not specified, then
-         * the javascript and declaration files will be produced for all the files in this program.
-         * If targetSourceFile is specified, then only the javascript and declaration for that
+         * Emits the JavaScript and declaration files.  If targetSourceFile is not specified, then
+         * the JavaScript and declaration files will be produced for all the files in this program.
+         * If targetSourceFile is specified, then only the JavaScript and declaration for that
          * specific file will be generated.
          *
          * If writeFile is not specified then the writeFile callback from the compiler host will be
-         * used for writing the javascript and declaration files.  Otherwise, the writeFile parameter
-         * will be invoked when writing the javascript and declaration files.
+         * used for writing the JavaScript and declaration files.  Otherwise, the writeFile parameter
+         * will be invoked when writing the JavaScript and declaration files.
          */
         emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback): EmitResult;
         getSyntacticDiagnostics(sourceFile?: SourceFile): Diagnostic[];
@@ -886,9 +913,10 @@ declare module "typescript" {
         NotAccessible = 1,
         CannotBeNamed = 2,
     }
+    type AnyImportSyntax = ImportDeclaration | ImportEqualsDeclaration;
     interface SymbolVisibilityResult {
         accessibility: SymbolAccessibility;
-        aliasesToMakeVisible?: ImportEqualsDeclaration[];
+        aliasesToMakeVisible?: AnyImportSyntax[];
         errorSymbolName?: string;
         errorNode?: Node;
     }
@@ -896,20 +924,22 @@ declare module "typescript" {
         errorModuleName?: string;
     }
     interface EmitResolver {
-        getGeneratedNameForNode(node: Node): string;
-        getExpressionNameSubstitution(node: Identifier): string;
-        hasExportDefaultValue(node: SourceFile): boolean;
-        isReferencedAliasDeclaration(node: Node): boolean;
+        hasGlobalName(name: string): boolean;
+        getExpressionNameSubstitution(node: Identifier, getGeneratedNameForNode: (node: Node) => string): string;
+        isValueAliasDeclaration(node: Node): boolean;
+        isReferencedAliasDeclaration(node: Node, checkChildren?: boolean): boolean;
         isTopLevelValueImportEqualsWithEntityName(node: ImportEqualsDeclaration): boolean;
         getNodeCheckFlags(node: Node): NodeCheckFlags;
         isDeclarationVisible(node: Declaration): boolean;
+        collectLinkedAliases(node: Identifier): Node[];
         isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;
         writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
+        writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
-        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
+        isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
-        isUnknownIdentifier(location: Node, name: string): boolean;
+        resolvesToSomeValue(location: Node, name: string): boolean;
         getBlockScopedVariableId(node: Identifier): number;
     }
     const enum SymbolFlags {
@@ -1016,6 +1046,7 @@ declare module "typescript" {
         ContextChecked = 64,
         EnumValuesComputed = 128,
         BlockScopedBindingInLoop = 256,
+        EmitDecorate = 512,
     }
     interface NodeLinks {
         resolvedType?: Type;
@@ -1135,17 +1166,6 @@ declare module "typescript" {
     interface TypeMapper {
         (t: Type): Type;
     }
-    interface TypeInferences {
-        primary: Type[];
-        secondary: Type[];
-    }
-    interface InferenceContext {
-        typeParameters: TypeParameter[];
-        inferUnionTypes: boolean;
-        inferences: TypeInferences[];
-        inferredTypes: Type[];
-        failedTypeParameterIndex?: number;
-    }
     interface DiagnosticMessage {
         key: string;
         category: DiagnosticCategory;
@@ -1173,7 +1193,6 @@ declare module "typescript" {
     interface CompilerOptions {
         allowNonTsExtensions?: boolean;
         charset?: string;
-        codepage?: number;
         declaration?: boolean;
         diagnostics?: boolean;
         emitBOM?: boolean;
@@ -1187,7 +1206,6 @@ declare module "typescript" {
         noErrorTruncation?: boolean;
         noImplicitAny?: boolean;
         noLib?: boolean;
-        noLibCheck?: boolean;
         noResolve?: boolean;
         out?: string;
         outDir?: string;
@@ -1200,6 +1218,7 @@ declare module "typescript" {
         target?: ScriptTarget;
         version?: boolean;
         watch?: boolean;
+        separateCompilation?: boolean;
         [option: string]: string | number | boolean;
     }
     const enum ModuleKind {
@@ -1442,11 +1461,26 @@ declare module "typescript" {
 declare module "typescript" {
     /** The version of the TypeScript compiler release */
     let version: string;
-    function createCompilerHost(options: CompilerOptions): CompilerHost;
+    function findConfigFile(searchPath: string): string;
+    function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost;
     function getPreEmitDiagnostics(program: Program): Diagnostic[];
     function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
     function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost): Program;
 }
+declare module "typescript" {
+    /**
+      * Read tsconfig.json file
+      * @param fileName The path to the config file
+      */
+    function readConfigFile(fileName: string): any;
+    /**
+      * Parse the contents of a config file (tsconfig.json).
+      * @param json The contents of the config file to parse
+      * @param basePath A root directory to resolve relative path entries in the config
+      *    file to. e.g. outDir
+      */
+    function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
+}
 declare module "typescript" {
     /** The version of the language service API */
     let servicesVersion: string;
@@ -1556,6 +1590,7 @@ declare module "typescript" {
         getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];
         getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[];
         getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[];
+        findReferences(fileName: string, position: number): ReferencedSymbol[];
         getNavigateToItems(searchValue: string, maxResultCount?: number): NavigateToItem[];
         getNavigationBarItems(fileName: string): NavigationBarItem[];
         getOutliningSpans(fileName: string): OutliningSpan[];
@@ -1642,6 +1677,10 @@ declare module "typescript" {
         containerKind: string;
         containerName: string;
     }
+    interface ReferencedSymbol {
+        definition: DefinitionInfo;
+        references: ReferenceEntry[];
+    }
     enum SymbolDisplayPartKind {
         aliasName = 0,
         className = 1,
@@ -1935,6 +1974,7 @@ declare module "typescript" {
         isCancellationRequested(): boolean;
         throwIfCancellationRequested(): void;
     }
+    function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
     function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
     let disableIncrementalParsing: boolean;
     function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;

bin/typescriptServices.d.ts

@@ -74,192 +74,198 @@ declare module ts {
         BarBarToken = 49,
         QuestionToken = 50,
         ColonToken = 51,
-        EqualsToken = 52,
-        PlusEqualsToken = 53,
-        MinusEqualsToken = 54,
-        AsteriskEqualsToken = 55,
-        SlashEqualsToken = 56,
-        PercentEqualsToken = 57,
-        LessThanLessThanEqualsToken = 58,
-        GreaterThanGreaterThanEqualsToken = 59,
-        GreaterThanGreaterThanGreaterThanEqualsToken = 60,
-        AmpersandEqualsToken = 61,
-        BarEqualsToken = 62,
-        CaretEqualsToken = 63,
-        Identifier = 64,
-        BreakKeyword = 65,
-        CaseKeyword = 66,
-        CatchKeyword = 67,
-        ClassKeyword = 68,
-        ConstKeyword = 69,
-        ContinueKeyword = 70,
-        DebuggerKeyword = 71,
-        DefaultKeyword = 72,
-        DeleteKeyword = 73,
-        DoKeyword = 74,
-        ElseKeyword = 75,
-        EnumKeyword = 76,
-        ExportKeyword = 77,
-        ExtendsKeyword = 78,
-        FalseKeyword = 79,
-        FinallyKeyword = 80,
-        ForKeyword = 81,
-        FunctionKeyword = 82,
-        IfKeyword = 83,
-        ImportKeyword = 84,
-        InKeyword = 85,
-        InstanceOfKeyword = 86,
-        NewKeyword = 87,
-        NullKeyword = 88,
-        ReturnKeyword = 89,
-        SuperKeyword = 90,
-        SwitchKeyword = 91,
-        ThisKeyword = 92,
-        ThrowKeyword = 93,
-        TrueKeyword = 94,
-        TryKeyword = 95,
-        TypeOfKeyword = 96,
-        VarKeyword = 97,
-        VoidKeyword = 98,
-        WhileKeyword = 99,
-        WithKeyword = 100,
-        AsKeyword = 101,
-        ImplementsKeyword = 102,
-        InterfaceKeyword = 103,
-        LetKeyword = 104,
-        PackageKeyword = 105,
-        PrivateKeyword = 106,
-        ProtectedKeyword = 107,
-        PublicKeyword = 108,
-        StaticKeyword = 109,
-        YieldKeyword = 110,
-        AnyKeyword = 111,
-        BooleanKeyword = 112,
-        ConstructorKeyword = 113,
-        DeclareKeyword = 114,
-        GetKeyword = 115,
-        ModuleKeyword = 116,
-        RequireKeyword = 117,
-        NumberKeyword = 118,
-        SetKeyword = 119,
-        StringKeyword = 120,
-        SymbolKeyword = 121,
-        TypeKeyword = 122,
-        FromKeyword = 123,
-        OfKeyword = 124,
-        QualifiedName = 125,
-        ComputedPropertyName = 126,
-        TypeParameter = 127,
-        Parameter = 128,
-        PropertySignature = 129,
-        PropertyDeclaration = 130,
-        MethodSignature = 131,
-        MethodDeclaration = 132,
-        Constructor = 133,
-        GetAccessor = 134,
-        SetAccessor = 135,
-        CallSignature = 136,
-        ConstructSignature = 137,
-        IndexSignature = 138,
-        TypeReference = 139,
-        FunctionType = 140,
-        ConstructorType = 141,
-        TypeQuery = 142,
-        TypeLiteral = 143,
-        ArrayType = 144,
-        TupleType = 145,
-        UnionType = 146,
-        ParenthesizedType = 147,
-        ObjectBindingPattern = 148,
-        ArrayBindingPattern = 149,
-        BindingElement = 150,
-        ArrayLiteralExpression = 151,
-        ObjectLiteralExpression = 152,
-        PropertyAccessExpression = 153,
-        ElementAccessExpression = 154,
-        CallExpression = 155,
-        NewExpression = 156,
-        TaggedTemplateExpression = 157,
-        TypeAssertionExpression = 158,
-        ParenthesizedExpression = 159,
-        FunctionExpression = 160,
-        ArrowFunction = 161,
-        DeleteExpression = 162,
-        TypeOfExpression = 163,
-        VoidExpression = 164,
-        PrefixUnaryExpression = 165,
-        PostfixUnaryExpression = 166,
-        BinaryExpression = 167,
-        ConditionalExpression = 168,
-        TemplateExpression = 169,
-        YieldExpression = 170,
-        SpreadElementExpression = 171,
-        OmittedExpression = 172,
-        TemplateSpan = 173,
-        Block = 174,
-        VariableStatement = 175,
-        EmptyStatement = 176,
-        ExpressionStatement = 177,
-        IfStatement = 178,
-        DoStatement = 179,
-        WhileStatement = 180,
-        ForStatement = 181,
-        ForInStatement = 182,
-        ForOfStatement = 183,
-        ContinueStatement = 184,
-        BreakStatement = 185,
-        ReturnStatement = 186,
-        WithStatement = 187,
-        SwitchStatement = 188,
-        LabeledStatement = 189,
-        ThrowStatement = 190,
-        TryStatement = 191,
-        DebuggerStatement = 192,
-        VariableDeclaration = 193,
-        VariableDeclarationList = 194,
-        FunctionDeclaration = 195,
-        ClassDeclaration = 196,
-        InterfaceDeclaration = 197,
-        TypeAliasDeclaration = 198,
-        EnumDeclaration = 199,
-        ModuleDeclaration = 200,
-        ModuleBlock = 201,
-        CaseBlock = 202,
-        ImportEqualsDeclaration = 203,
-        ImportDeclaration = 204,
-        ImportClause = 205,
-        NamespaceImport = 206,
-        NamedImports = 207,
-        ImportSpecifier = 208,
-        ExportAssignment = 209,
-        ExportDeclaration = 210,
-        NamedExports = 211,
-        ExportSpecifier = 212,
-        ExternalModuleReference = 213,
-        CaseClause = 214,
-        DefaultClause = 215,
-        HeritageClause = 216,
-        CatchClause = 217,
-        PropertyAssignment = 218,
-        ShorthandPropertyAssignment = 219,
-        EnumMember = 220,
-        SourceFile = 221,
-        SyntaxList = 222,
-        Count = 223,
-        FirstAssignment = 52,
-        LastAssignment = 63,
-        FirstReservedWord = 65,
-        LastReservedWord = 100,
-        FirstKeyword = 65,
-        LastKeyword = 124,
-        FirstFutureReservedWord = 102,
-        LastFutureReservedWord = 110,
-        FirstTypeNode = 139,
-        LastTypeNode = 147,
+        AtToken = 52,
+        EqualsToken = 53,
+        PlusEqualsToken = 54,
+        MinusEqualsToken = 55,
+        AsteriskEqualsToken = 56,
+        SlashEqualsToken = 57,
+        PercentEqualsToken = 58,
+        LessThanLessThanEqualsToken = 59,
+        GreaterThanGreaterThanEqualsToken = 60,
+        GreaterThanGreaterThanGreaterThanEqualsToken = 61,
+        AmpersandEqualsToken = 62,
+        BarEqualsToken = 63,
+        CaretEqualsToken = 64,
+        Identifier = 65,
+        BreakKeyword = 66,
+        CaseKeyword = 67,
+        CatchKeyword = 68,
+        ClassKeyword = 69,
+        ConstKeyword = 70,
+        ContinueKeyword = 71,
+        DebuggerKeyword = 72,
+        DefaultKeyword = 73,
+        DeleteKeyword = 74,
+        DoKeyword = 75,
+        ElseKeyword = 76,
+        EnumKeyword = 77,
+        ExportKeyword = 78,
+        ExtendsKeyword = 79,
+        FalseKeyword = 80,
+        FinallyKeyword = 81,
+        ForKeyword = 82,
+        FunctionKeyword = 83,
+        IfKeyword = 84,
+        ImportKeyword = 85,
+        InKeyword = 86,
+        InstanceOfKeyword = 87,
+        NewKeyword = 88,
+        NullKeyword = 89,
+        ReturnKeyword = 90,
+        SuperKeyword = 91,
+        SwitchKeyword = 92,
+        ThisKeyword = 93,
+        ThrowKeyword = 94,
+        TrueKeyword = 95,
+        TryKeyword = 96,
+        TypeOfKeyword = 97,
+        VarKeyword = 98,
+        VoidKeyword = 99,
+        WhileKeyword = 100,
+        WithKeyword = 101,
+        AsKeyword = 102,
+        ImplementsKeyword = 103,
+        InterfaceKeyword = 104,
+        LetKeyword = 105,
+        PackageKeyword = 106,
+        PrivateKeyword = 107,
+        ProtectedKeyword = 108,
+        PublicKeyword = 109,
+        StaticKeyword = 110,
+        YieldKeyword = 111,
+        AnyKeyword = 112,
+        BooleanKeyword = 113,
+        ConstructorKeyword = 114,
+        DeclareKeyword = 115,
+        GetKeyword = 116,
+        ModuleKeyword = 117,
+        RequireKeyword = 118,
+        NumberKeyword = 119,
+        SetKeyword = 120,
+        StringKeyword = 121,
+        SymbolKeyword = 122,
+        TypeKeyword = 123,
+        FromKeyword = 124,
+        OfKeyword = 125,
+        QualifiedName = 126,
+        ComputedPropertyName = 127,
+        TypeParameter = 128,
+        Parameter = 129,
+        Decorator = 130,
+        PropertySignature = 131,
+        PropertyDeclaration = 132,
+        MethodSignature = 133,
+        MethodDeclaration = 134,
+        Constructor = 135,
+        GetAccessor = 136,
+        SetAccessor = 137,
+        CallSignature = 138,
+        ConstructSignature = 139,
+        IndexSignature = 140,
+        TypeReference = 141,
+        FunctionType = 142,
+        ConstructorType = 143,
+        TypeQuery = 144,
+        TypeLiteral = 145,
+        ArrayType = 146,
+        TupleType = 147,
+        UnionType = 148,
+        ParenthesizedType = 149,
+        ObjectBindingPattern = 150,
+        ArrayBindingPattern = 151,
+        BindingElement = 152,
+        ArrayLiteralExpression = 153,
+        ObjectLiteralExpression = 154,
+        PropertyAccessExpression = 155,
+        ElementAccessExpression = 156,
+        CallExpression = 157,
+        NewExpression = 158,
+        TaggedTemplateExpression = 159,
+        TypeAssertionExpression = 160,
+        ParenthesizedExpression = 161,
+        FunctionExpression = 162,
+        ArrowFunction = 163,
+        DeleteExpression = 164,
+        TypeOfExpression = 165,
+        VoidExpression = 166,
+        PrefixUnaryExpression = 167,
+        PostfixUnaryExpression = 168,
+        BinaryExpression = 169,
+        ConditionalExpression = 170,
+        TemplateExpression = 171,
+        YieldExpression = 172,
+        SpreadElementExpression = 173,
+        ClassExpression = 174,
+        OmittedExpression = 175,
+        TemplateSpan = 176,
+        HeritageClauseElement = 177,
+        SemicolonClassElement = 178,
+        Block = 179,
+        VariableStatement = 180,
+        EmptyStatement = 181,
+        ExpressionStatement = 182,
+        IfStatement = 183,
+        DoStatement = 184,
+        WhileStatement = 185,
+        ForStatement = 186,
+        ForInStatement = 187,
+        ForOfStatement = 188,
+        ContinueStatement = 189,
+        BreakStatement = 190,
+        ReturnStatement = 191,
+        WithStatement = 192,
+        SwitchStatement = 193,
+        LabeledStatement = 194,
+        ThrowStatement = 195,
+        TryStatement = 196,
+        DebuggerStatement = 197,
+        VariableDeclaration = 198,
+        VariableDeclarationList = 199,
+        FunctionDeclaration = 200,
+        ClassDeclaration = 201,
+        InterfaceDeclaration = 202,
+        TypeAliasDeclaration = 203,
+        EnumDeclaration = 204,
+        ModuleDeclaration = 205,
+        ModuleBlock = 206,
+        CaseBlock = 207,
+        ImportEqualsDeclaration = 208,
+        ImportDeclaration = 209,
+        ImportClause = 210,
+        NamespaceImport = 211,
+        NamedImports = 212,
+        ImportSpecifier = 213,
+        ExportAssignment = 214,
+        ExportDeclaration = 215,
+        NamedExports = 216,
+        ExportSpecifier = 217,
+        MissingDeclaration = 218,
+        ExternalModuleReference = 219,
+        CaseClause = 220,
+        DefaultClause = 221,
+        HeritageClause = 222,
+        CatchClause = 223,
+        PropertyAssignment = 224,
+        ShorthandPropertyAssignment = 225,
+        EnumMember = 226,
+        SourceFile = 227,
+        SyntaxList = 228,
+        Count = 229,
+        FirstAssignment = 53,
+        LastAssignment = 64,
+        FirstReservedWord = 66,
+        LastReservedWord = 101,
+        FirstKeyword = 66,
+        LastKeyword = 125,
+        FirstFutureReservedWord = 103,
+        LastFutureReservedWord = 111,
+        FirstTypeNode = 141,
+        LastTypeNode = 149,
         FirstPunctuation = 14,
-        LastPunctuation = 63,
+        LastPunctuation = 64,
         FirstToken = 0,
-        LastToken = 124,
+        LastToken = 125,
         FirstTriviaToken = 2,
         LastTriviaToken = 6,
         FirstLiteralToken = 7,
@@ -267,8 +273,8 @@ declare module ts {
         FirstTemplateToken = 10,
         LastTemplateToken = 13,
         FirstBinaryOperator = 24,
-        LastBinaryOperator = 63,
-        FirstNode = 125,
+        LastBinaryOperator = 64,
+        FirstNode = 126,
     }
     const enum NodeFlags {
         Export = 1,
@@ -284,6 +290,7 @@ declare module ts {
         Let = 4096,
         Const = 8192,
         OctalLiteral = 16384,
+        ExportContext = 32768,
         Modifier = 499,
         AccessibilityModifier = 112,
         BlockScoped = 12288,
@@ -293,10 +300,11 @@ declare module ts {
         DisallowIn = 2,
         Yield = 4,
         GeneratorParameter = 8,
-        ThisNodeHasError = 16,
-        ParserGeneratedFlags = 31,
-        ThisNodeOrAnySubNodesHasError = 32,
-        HasAggregatedChildData = 64,
+        Decorator = 16,
+        ThisNodeHasError = 32,
+        ParserGeneratedFlags = 63,
+        ThisNodeOrAnySubNodesHasError = 64,
+        HasAggregatedChildData = 128,
     }
     const enum RelationComparisonResult {
         Succeeded = 1,
@@ -307,6 +315,7 @@ declare module ts {
         kind: SyntaxKind;
         flags: NodeFlags;
         parserContextFlags?: ParserContextFlags;
+        decorators?: NodeArray<Decorator>;
         modifiers?: ModifiersArray;
         id?: number;
         parent?: Node;
@@ -337,6 +346,9 @@ declare module ts {
     interface ComputedPropertyName extends Node {
         expression: Expression;
     }
+    interface Decorator extends Node {
+        expression: LeftHandSideExpression;
+    }
     interface TypeParameterDeclaration extends Declaration {
         name: Identifier;
         constraint?: TypeNode;
@@ -423,6 +435,9 @@ declare module ts {
     interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {
         body?: Block;
     }
+    interface SemicolonClassElement extends ClassElement {
+        _semicolonClassElementBrand: any;
+    }
     interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
         _accessorDeclarationBrand: any;
         body: Block;
@@ -516,6 +531,9 @@ declare module ts {
         name?: Identifier;
         body: Block | Expression;
     }
+    interface ArrowFunction extends Expression, FunctionLikeDeclaration {
+        equalsGreaterThanToken: Node;
+    }
     interface LiteralExpression extends PrimaryExpression {
         text: string;
         isUnterminated?: boolean;
@@ -558,6 +576,10 @@ declare module ts {
         typeArguments?: NodeArray<TypeNode>;
         arguments: NodeArray<Expression>;
     }
+    interface HeritageClauseElement extends Node {
+        expression: LeftHandSideExpression;
+        typeArguments?: NodeArray<TypeNode>;
+    }
     interface NewExpression extends CallExpression, PrimaryExpression {
     }
     interface TaggedTemplateExpression extends MemberExpression {
@@ -652,12 +674,16 @@ declare module ts {
     interface ModuleElement extends Node {
         _moduleElementBrand: any;
     }
-    interface ClassDeclaration extends Declaration, ModuleElement {
+    interface ClassLikeDeclaration extends Declaration {
         name?: Identifier;
         typeParameters?: NodeArray<TypeParameterDeclaration>;
         heritageClauses?: NodeArray<HeritageClause>;
         members: NodeArray<ClassElement>;
     }
+    interface ClassDeclaration extends ClassLikeDeclaration, Statement {
+    }
+    interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
+    }
     interface ClassElement extends Declaration {
         _classElementBrand: any;
     }
@@ -669,7 +695,7 @@ declare module ts {
     }
     interface HeritageClause extends Node {
         token: SyntaxKind;
-        types?: NodeArray<TypeReferenceNode>;
+        types?: NodeArray<HeritageClauseElement>;
     }
     interface TypeAliasDeclaration extends Declaration, ModuleElement {
         name: Identifier;
@@ -725,7 +751,8 @@ declare module ts {
     type ExportSpecifier = ImportOrExportSpecifier;
     interface ExportAssignment extends Declaration, ModuleElement {
         isExportEquals?: boolean;
-        expression: Expression;
+        expression?: Expression;
+        type?: TypeNode;
     }
     interface FileReference extends TextRange {
         fileName: string;
@@ -760,14 +787,14 @@ declare module ts {
     interface Program extends ScriptReferenceHost {
         getSourceFiles(): SourceFile[];
         /**
-         * Emits the javascript and declaration files.  If targetSourceFile is not specified, then
-         * the javascript and declaration files will be produced for all the files in this program.
-         * If targetSourceFile is specified, then only the javascript and declaration for that
+         * Emits the JavaScript and declaration files.  If targetSourceFile is not specified, then
+         * the JavaScript and declaration files will be produced for all the files in this program.
+         * If targetSourceFile is specified, then only the JavaScript and declaration for that
          * specific file will be generated.
          *
          * If writeFile is not specified then the writeFile callback from the compiler host will be
-         * used for writing the javascript and declaration files.  Otherwise, the writeFile parameter
-         * will be invoked when writing the javascript and declaration files.
+         * used for writing the JavaScript and declaration files.  Otherwise, the writeFile parameter
+         * will be invoked when writing the JavaScript and declaration files.
          */
         emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback): EmitResult;
         getSyntacticDiagnostics(sourceFile?: SourceFile): Diagnostic[];
@@ -886,9 +913,10 @@ declare module ts {
         NotAccessible = 1,
         CannotBeNamed = 2,
     }
+    type AnyImportSyntax = ImportDeclaration | ImportEqualsDeclaration;
     interface SymbolVisibilityResult {
         accessibility: SymbolAccessibility;
-        aliasesToMakeVisible?: ImportEqualsDeclaration[];
+        aliasesToMakeVisible?: AnyImportSyntax[];
         errorSymbolName?: string;
         errorNode?: Node;
     }
@@ -896,20 +924,22 @@ declare module ts {
         errorModuleName?: string;
     }
     interface EmitResolver {
-        getGeneratedNameForNode(node: Node): string;
-        getExpressionNameSubstitution(node: Identifier): string;
-        hasExportDefaultValue(node: SourceFile): boolean;
-        isReferencedAliasDeclaration(node: Node): boolean;
+        hasGlobalName(name: string): boolean;
+        getExpressionNameSubstitution(node: Identifier, getGeneratedNameForNode: (node: Node) => string): string;
+        isValueAliasDeclaration(node: Node): boolean;
+        isReferencedAliasDeclaration(node: Node, checkChildren?: boolean): boolean;
         isTopLevelValueImportEqualsWithEntityName(node: ImportEqualsDeclaration): boolean;
         getNodeCheckFlags(node: Node): NodeCheckFlags;
         isDeclarationVisible(node: Declaration): boolean;
+        collectLinkedAliases(node: Identifier): Node[];
         isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;
         writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
+        writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
-        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
+        isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
-        isUnknownIdentifier(location: Node, name: string): boolean;
+        resolvesToSomeValue(location: Node, name: string): boolean;
         getBlockScopedVariableId(node: Identifier): number;
     }
     const enum SymbolFlags {
@@ -1016,6 +1046,7 @@ declare module ts {
         ContextChecked = 64,
         EnumValuesComputed = 128,
         BlockScopedBindingInLoop = 256,
+        EmitDecorate = 512,
     }
     interface NodeLinks {
         resolvedType?: Type;
@@ -1135,17 +1166,6 @@ declare module ts {
     interface TypeMapper {
         (t: Type): Type;
     }
-    interface TypeInferences {
-        primary: Type[];
-        secondary: Type[];
-    }
-    interface InferenceContext {
-        typeParameters: TypeParameter[];
-        inferUnionTypes: boolean;
-        inferences: TypeInferences[];
-        inferredTypes: Type[];
-        failedTypeParameterIndex?: number;
-    }
     interface DiagnosticMessage {
         key: string;
         category: DiagnosticCategory;
@@ -1173,7 +1193,6 @@ declare module ts {
     interface CompilerOptions {
         allowNonTsExtensions?: boolean;
         charset?: string;
-        codepage?: number;
         declaration?: boolean;
         diagnostics?: boolean;
         emitBOM?: boolean;
@@ -1187,7 +1206,6 @@ declare module ts {
         noErrorTruncation?: boolean;
         noImplicitAny?: boolean;
         noLib?: boolean;
-        noLibCheck?: boolean;
         noResolve?: boolean;
         out?: string;
         outDir?: string;
@@ -1200,6 +1218,7 @@ declare module ts {
         target?: ScriptTarget;
         version?: boolean;
         watch?: boolean;
+        separateCompilation?: boolean;
         [option: string]: string | number | boolean;
     }
     const enum ModuleKind {
@@ -1442,11 +1461,26 @@ declare module ts {
 declare module ts {
     /** The version of the TypeScript compiler release */
     let version: string;
-    function createCompilerHost(options: CompilerOptions): CompilerHost;
+    function findConfigFile(searchPath: string): string;
+    function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost;
     function getPreEmitDiagnostics(program: Program): Diagnostic[];
     function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
     function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost): Program;
 }
+declare module ts {
+    /**
+      * Read tsconfig.json file
+      * @param fileName The path to the config file
+      */
+    function readConfigFile(fileName: string): any;
+    /**
+      * Parse the contents of a config file (tsconfig.json).
+      * @param json The contents of the config file to parse
+      * @param basePath A root directory to resolve relative path entries in the config
+      *    file to. e.g. outDir
+      */
+    function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
+}
 declare module ts {
     /** The version of the language service API */
     let servicesVersion: string;
@@ -1556,6 +1590,7 @@ declare module ts {
         getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];
         getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[];
         getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[];
+        findReferences(fileName: string, position: number): ReferencedSymbol[];
         getNavigateToItems(searchValue: string, maxResultCount?: number): NavigateToItem[];
         getNavigationBarItems(fileName: string): NavigationBarItem[];
         getOutliningSpans(fileName: string): OutliningSpan[];
@@ -1642,6 +1677,10 @@ declare module ts {
         containerKind: string;
         containerName: string;
     }
+    interface ReferencedSymbol {
+        definition: DefinitionInfo;
+        references: ReferenceEntry[];
+    }
     enum SymbolDisplayPartKind {
         aliasName = 0,
         className = 1,
@@ -1935,6 +1974,7 @@ declare module ts {
         isCancellationRequested(): boolean;
         throwIfCancellationRequested(): void;
     }
+    function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
     function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
     let disableIncrementalParsing: boolean;
     function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;

bin/typescriptServices_internal.d.ts

@@ -41,6 +41,10 @@ declare module ts {
      */
     function lastOrUndefined<T>(array: T[]): T;
     function binarySearch(array: number[], value: number): number;
+    function reduceLeft<T>(array: T[], f: (a: T, x: T) => T): T;
+    function reduceLeft<T, U>(array: T[], f: (a: U, x: T) => U, initial: U): U;
+    function reduceRight<T>(array: T[], f: (a: T, x: T) => T): T;
+    function reduceRight<T, U>(array: T[], f: (a: U, x: T) => U, initial: U): U;
     function hasProperty<T>(map: Map<T>, key: string): boolean;
     function getProperty<T>(map: Map<T>, key: string): T;
     function isEmpty<T>(map: Map<T>): boolean;
@@ -49,7 +53,6 @@ declare module ts {
     function forEachValue<T, U>(map: Map<T>, callback: (value: T) => U): U;
     function forEachKey<T, U>(map: Map<T>, callback: (key: string) => U): U;
     function lookUp<T>(map: Map<T>, key: string): T;
-    function mapToArray<T>(map: Map<T>): T[];
     function copyMap<T>(source: Map<T>, target: Map<T>): void;
     /**
      * Creates a map from the elements of an array.
@@ -184,7 +187,7 @@ declare module ts {
     function isConst(node: Node): boolean;
     function isLet(node: Node): boolean;
     function isPrologueDirective(node: Node): boolean;
-    function getLeadingCommentRangesOfNode(node: Node, sourceFileOfNode?: SourceFile): CommentRange[];
+    function getLeadingCommentRangesOfNode(node: Node, sourceFileOfNode: SourceFile): CommentRange[];
     function getJsDocComments(node: Node, sourceFileOfNode: SourceFile): CommentRange[];
     let fullTripleSlashReferencePathRegEx: RegExp;
     function forEachReturnStatement<T>(body: Block, visitor: (stmt: ReturnStatement) => T): T;
@@ -195,6 +198,10 @@ declare module ts {
     function getThisContainer(node: Node, includeArrowFunctions: boolean): Node;
     function getSuperContainer(node: Node, includeFunctions: boolean): Node;
     function getInvokedExpression(node: CallLikeExpression): Expression;
+    function nodeCanBeDecorated(node: Node): boolean;
+    function nodeIsDecorated(node: Node): boolean;
+    function childIsDecorated(node: Node): boolean;
+    function nodeOrChildIsDecorated(node: Node): boolean;
     function isExpression(node: Node): boolean;
     function isInstantiatedModule(node: ModuleDeclaration, preserveConstEnums: boolean): boolean;
     function isExternalModuleImportEqualsDeclaration(node: Node): boolean;
@@ -211,10 +218,12 @@ declare module ts {
     function isInAmbientContext(node: Node): boolean;
     function isDeclaration(node: Node): boolean;
     function isStatement(n: Node): boolean;
+    function isClassElement(n: Node): boolean;
     function isDeclarationName(name: Node): boolean;
-    function getClassBaseTypeNode(node: ClassDeclaration): TypeReferenceNode;
-    function getClassImplementedTypeNodes(node: ClassDeclaration): NodeArray<TypeReferenceNode>;
-    function getInterfaceBaseTypeNodes(node: InterfaceDeclaration): NodeArray<TypeReferenceNode>;
+    function isAliasSymbolDeclaration(node: Node): boolean;
+    function getClassExtendsHeritageClauseElement(node: ClassLikeDeclaration): HeritageClauseElement;
+    function getClassImplementsHeritageClauseElements(node: ClassDeclaration): NodeArray<HeritageClauseElement>;
+    function getInterfaceBaseTypeNodes(node: InterfaceDeclaration): NodeArray<HeritageClauseElement>;
     function getHeritageClause(clauses: NodeArray<HeritageClause>, kind: SyntaxKind): HeritageClause;
     function tryResolveScriptReference(host: ScriptReferenceHost, sourceFile: SourceFile, reference: FileReference): SourceFile;
     function getAncestor(node: Node, kind: SyntaxKind): Node;
@@ -270,7 +279,6 @@ declare module ts {
     function nodeStartsNewLexicalEnvironment(n: Node): boolean;
     function nodeIsSynthesized(node: Node): boolean;
     function createSynthesizedNode(kind: SyntaxKind, startsOnNewLine?: boolean): Node;
-    function generateUniqueName(baseName: string, isExistingName: (name: string) => boolean): string;
     /**
      * Based heavily on the abstract 'Quote'/'QuoteJSONString' operation from ECMA-262 (24.3.2.2),
      * but augmented for a few select characters (e.g. lineSeparator, paragraphSeparator, nextLine)
@@ -278,11 +286,54 @@ declare module ts {
      */
     function escapeString(s: string): string;
     function escapeNonAsciiCharacters(s: string): string;
+    interface EmitTextWriter {
+        write(s: string): void;
+        writeTextOfNode(sourceFile: SourceFile, node: Node): void;
+        writeLine(): void;
+        increaseIndent(): void;
+        decreaseIndent(): void;
+        getText(): string;
+        rawWrite(s: string): void;
+        writeLiteral(s: string): void;
+        getTextPos(): number;
+        getLine(): number;
+        getColumn(): number;
+        getIndent(): number;
+    }
+    function getIndentString(level: number): string;
+    function getIndentSize(): number;
+    function createTextWriter(newLine: String): EmitTextWriter;
+    function getOwnEmitOutputFilePath(sourceFile: SourceFile, host: EmitHost, extension: string): string;
+    function getSourceFilePathInNewDir(sourceFile: SourceFile, host: EmitHost, newDirPath: string): string;
+    function writeFile(host: EmitHost, diagnostics: Diagnostic[], fileName: string, data: string, writeByteOrderMark: boolean): void;
+    function getLineOfLocalPosition(currentSourceFile: SourceFile, pos: number): number;
+    function getFirstConstructorWithBody(node: ClassLikeDeclaration): ConstructorDeclaration;
+    function shouldEmitToOwnFile(sourceFile: SourceFile, compilerOptions: CompilerOptions): boolean;
+    function getAllAccessorDeclarations(declarations: NodeArray<Declaration>, accessor: AccessorDeclaration): {
+        firstAccessor: AccessorDeclaration;
+        secondAccessor: AccessorDeclaration;
+        getAccessor: AccessorDeclaration;
+        setAccessor: AccessorDeclaration;
+    };
+    function emitNewLineBeforeLeadingComments(currentSourceFile: SourceFile, writer: EmitTextWriter, node: TextRange, leadingComments: CommentRange[]): void;
+    function emitComments(currentSourceFile: SourceFile, writer: EmitTextWriter, comments: CommentRange[], trailingSeparator: boolean, newLine: string, writeComment: (currentSourceFile: SourceFile, writer: EmitTextWriter, comment: CommentRange, newLine: string) => void): void;
+    function writeCommentRange(currentSourceFile: SourceFile, writer: EmitTextWriter, comment: CommentRange, newLine: string): void;
+    function isSupportedHeritageClauseElement(node: HeritageClauseElement): boolean;
+    function isRightSideOfQualifiedNameOrPropertyAccess(node: Node): boolean;
+    function getLocalSymbolForExportDefault(symbol: Symbol): Symbol;
 }
 declare module ts {
-    var optionDeclarations: CommandLineOption[];
-    function parseCommandLine(commandLine: string[]): ParsedCommandLine;
+    /**
+      * Read tsconfig.json file
+      * @param fileName The path to the config file
+      */
     function readConfigFile(fileName: string): any;
+    /**
+      * Parse the contents of a config file (tsconfig.json).
+      * @param json The contents of the config file to parse
+      * @param basePath A root directory to resolve relative path entries in the config
+      *    file to. e.g. outDir
+      */
     function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
 }
 declare module ts {
@@ -297,7 +348,10 @@ declare module ts {
     function rangeContainsStartEnd(range: TextRange, start: number, end: number): boolean;
     function rangeOverlapsWithStartEnd(r1: TextRange, start: number, end: number): boolean;
     function startEndOverlapsWithStartEnd(start1: number, end1: number, start2: number, end2: number): boolean;
+    function positionBelongsToNode(candidate: Node, position: number, sourceFile: SourceFile): boolean;
+    function isCompletedNode(n: Node, sourceFile: SourceFile): boolean;
     function findListItemInfo(node: Node): ListItemInfo;
+    function hasChildOfKind(n: Node, kind: SyntaxKind, sourceFile?: SourceFile): boolean;
     function findChildOfKind(n: Node, kind: SyntaxKind, sourceFile?: SourceFile): Node;
     function findContainingList(node: Node): Node;
     function getTouchingWord(sourceFile: SourceFile, position: number): Node;
@@ -320,9 +374,11 @@ declare module ts {
     function getNodeModifiers(node: Node): string;
     function getTypeArgumentOrTypeParameterList(node: Node): NodeArray<Node>;
     function isToken(n: Node): boolean;
+    function isWord(kind: SyntaxKind): boolean;
     function isComment(kind: SyntaxKind): boolean;
     function isPunctuation(kind: SyntaxKind): boolean;
     function isInsideTemplateLiteral(node: LiteralExpression, position: number): boolean;
+    function isAccessibilityModifier(kind: SyntaxKind): boolean;
     function compareDataObjects(dst: any, src: any): boolean;
 }
 declare module ts {
@@ -333,6 +389,7 @@ declare module ts {
     function keywordPart(kind: SyntaxKind): SymbolDisplayPart;
     function punctuationPart(kind: SyntaxKind): SymbolDisplayPart;
     function operatorPart(kind: SyntaxKind): SymbolDisplayPart;
+    function textOrKeywordPart(text: string): SymbolDisplayPart;
     function textPart(text: string): SymbolDisplayPart;
     function lineBreakPart(): SymbolDisplayPart;
     function mapToDisplayParts(writeDisplayParts: (writer: DisplayPartsSymbolWriter) => void): SymbolDisplayPart[];

bin/typescript_internal.d.ts

@@ -41,6 +41,10 @@ declare module "typescript" {
      */
     function lastOrUndefined<T>(array: T[]): T;
     function binarySearch(array: number[], value: number): number;
+    function reduceLeft<T>(array: T[], f: (a: T, x: T) => T): T;
+    function reduceLeft<T, U>(array: T[], f: (a: U, x: T) => U, initial: U): U;
+    function reduceRight<T>(array: T[], f: (a: T, x: T) => T): T;
+    function reduceRight<T, U>(array: T[], f: (a: U, x: T) => U, initial: U): U;
     function hasProperty<T>(map: Map<T>, key: string): boolean;
     function getProperty<T>(map: Map<T>, key: string): T;
     function isEmpty<T>(map: Map<T>): boolean;
@@ -49,7 +53,6 @@ declare module "typescript" {
     function forEachValue<T, U>(map: Map<T>, callback: (value: T) => U): U;
     function forEachKey<T, U>(map: Map<T>, callback: (key: string) => U): U;
     function lookUp<T>(map: Map<T>, key: string): T;
-    function mapToArray<T>(map: Map<T>): T[];
     function copyMap<T>(source: Map<T>, target: Map<T>): void;
     /**
      * Creates a map from the elements of an array.
@@ -184,7 +187,7 @@ declare module "typescript" {
     function isConst(node: Node): boolean;
     function isLet(node: Node): boolean;
     function isPrologueDirective(node: Node): boolean;
-    function getLeadingCommentRangesOfNode(node: Node, sourceFileOfNode?: SourceFile): CommentRange[];
+    function getLeadingCommentRangesOfNode(node: Node, sourceFileOfNode: SourceFile): CommentRange[];
     function getJsDocComments(node: Node, sourceFileOfNode: SourceFile): CommentRange[];
     let fullTripleSlashReferencePathRegEx: RegExp;
     function forEachReturnStatement<T>(body: Block, visitor: (stmt: ReturnStatement) => T): T;
@@ -195,6 +198,10 @@ declare module "typescript" {
     function getThisContainer(node: Node, includeArrowFunctions: boolean): Node;
     function getSuperContainer(node: Node, includeFunctions: boolean): Node;
     function getInvokedExpression(node: CallLikeExpression): Expression;
+    function nodeCanBeDecorated(node: Node): boolean;
+    function nodeIsDecorated(node: Node): boolean;
+    function childIsDecorated(node: Node): boolean;
+    function nodeOrChildIsDecorated(node: Node): boolean;
     function isExpression(node: Node): boolean;
     function isInstantiatedModule(node: ModuleDeclaration, preserveConstEnums: boolean): boolean;
     function isExternalModuleImportEqualsDeclaration(node: Node): boolean;
@@ -211,10 +218,12 @@ declare module "typescript" {
     function isInAmbientContext(node: Node): boolean;
     function isDeclaration(node: Node): boolean;
     function isStatement(n: Node): boolean;
+    function isClassElement(n: Node): boolean;
     function isDeclarationName(name: Node): boolean;
-    function getClassBaseTypeNode(node: ClassDeclaration): TypeReferenceNode;
-    function getClassImplementedTypeNodes(node: ClassDeclaration): NodeArray<TypeReferenceNode>;
-    function getInterfaceBaseTypeNodes(node: InterfaceDeclaration): NodeArray<TypeReferenceNode>;
+    function isAliasSymbolDeclaration(node: Node): boolean;
+    function getClassExtendsHeritageClauseElement(node: ClassLikeDeclaration): HeritageClauseElement;
+    function getClassImplementsHeritageClauseElements(node: ClassDeclaration): NodeArray<HeritageClauseElement>;
+    function getInterfaceBaseTypeNodes(node: InterfaceDeclaration): NodeArray<HeritageClauseElement>;
     function getHeritageClause(clauses: NodeArray<HeritageClause>, kind: SyntaxKind): HeritageClause;
     function tryResolveScriptReference(host: ScriptReferenceHost, sourceFile: SourceFile, reference: FileReference): SourceFile;
     function getAncestor(node: Node, kind: SyntaxKind): Node;
@@ -270,7 +279,6 @@ declare module "typescript" {
     function nodeStartsNewLexicalEnvironment(n: Node): boolean;
     function nodeIsSynthesized(node: Node): boolean;
     function createSynthesizedNode(kind: SyntaxKind, startsOnNewLine?: boolean): Node;
-    function generateUniqueName(baseName: string, isExistingName: (name: string) => boolean): string;
     /**
      * Based heavily on the abstract 'Quote'/'QuoteJSONString' operation from ECMA-262 (24.3.2.2),
      * but augmented for a few select characters (e.g. lineSeparator, paragraphSeparator, nextLine)
@@ -278,11 +286,54 @@ declare module "typescript" {
      */
     function escapeString(s: string): string;
     function escapeNonAsciiCharacters(s: string): string;
+    interface EmitTextWriter {
+        write(s: string): void;
+        writeTextOfNode(sourceFile: SourceFile, node: Node): void;
+        writeLine(): void;
+        increaseIndent(): void;
+        decreaseIndent(): void;
+        getText(): string;
+        rawWrite(s: string): void;
+        writeLiteral(s: string): void;
+        getTextPos(): number;
+        getLine(): number;
+        getColumn(): number;
+        getIndent(): number;
+    }
+    function getIndentString(level: number): string;
+    function getIndentSize(): number;
+    function createTextWriter(newLine: String): EmitTextWriter;
+    function getOwnEmitOutputFilePath(sourceFile: SourceFile, host: EmitHost, extension: string): string;
+    function getSourceFilePathInNewDir(sourceFile: SourceFile, host: EmitHost, newDirPath: string): string;
+    function writeFile(host: EmitHost, diagnostics: Diagnostic[], fileName: string, data: string, writeByteOrderMark: boolean): void;
+    function getLineOfLocalPosition(currentSourceFile: SourceFile, pos: number): number;
+    function getFirstConstructorWithBody(node: ClassLikeDeclaration): ConstructorDeclaration;
+    function shouldEmitToOwnFile(sourceFile: SourceFile, compilerOptions: CompilerOptions): boolean;
+    function getAllAccessorDeclarations(declarations: NodeArray<Declaration>, accessor: AccessorDeclaration): {
+        firstAccessor: AccessorDeclaration;
+        secondAccessor: AccessorDeclaration;
+        getAccessor: AccessorDeclaration;
+        setAccessor: AccessorDeclaration;
+    };
+    function emitNewLineBeforeLeadingComments(currentSourceFile: SourceFile, writer: EmitTextWriter, node: TextRange, leadingComments: CommentRange[]): void;
+    function emitComments(currentSourceFile: SourceFile, writer: EmitTextWriter, comments: CommentRange[], trailingSeparator: boolean, newLine: string, writeComment: (currentSourceFile: SourceFile, writer: EmitTextWriter, comment: CommentRange, newLine: string) => void): void;
+    function writeCommentRange(currentSourceFile: SourceFile, writer: EmitTextWriter, comment: CommentRange, newLine: string): void;
+    function isSupportedHeritageClauseElement(node: HeritageClauseElement): boolean;
+    function isRightSideOfQualifiedNameOrPropertyAccess(node: Node): boolean;
+    function getLocalSymbolForExportDefault(symbol: Symbol): Symbol;
 }
 declare module "typescript" {
-    var optionDeclarations: CommandLineOption[];
-    function parseCommandLine(commandLine: string[]): ParsedCommandLine;
+    /**
+      * Read tsconfig.json file
+      * @param fileName The path to the config file
+      */
     function readConfigFile(fileName: string): any;
+    /**
+      * Parse the contents of a config file (tsconfig.json).
+      * @param json The contents of the config file to parse
+      * @param basePath A root directory to resolve relative path entries in the config
+      *    file to. e.g. outDir
+      */
     function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
 }
 declare module "typescript" {
@@ -297,7 +348,10 @@ declare module "typescript" {
     function rangeContainsStartEnd(range: TextRange, start: number, end: number): boolean;
     function rangeOverlapsWithStartEnd(r1: TextRange, start: number, end: number): boolean;
     function startEndOverlapsWithStartEnd(start1: number, end1: number, start2: number, end2: number): boolean;
+    function positionBelongsToNode(candidate: Node, position: number, sourceFile: SourceFile): boolean;
+    function isCompletedNode(n: Node, sourceFile: SourceFile): boolean;
     function findListItemInfo(node: Node): ListItemInfo;
+    function hasChildOfKind(n: Node, kind: SyntaxKind, sourceFile?: SourceFile): boolean;
     function findChildOfKind(n: Node, kind: SyntaxKind, sourceFile?: SourceFile): Node;
     function findContainingList(node: Node): Node;
     function getTouchingWord(sourceFile: SourceFile, position: number): Node;
@@ -320,9 +374,11 @@ declare module "typescript" {
     function getNodeModifiers(node: Node): string;
     function getTypeArgumentOrTypeParameterList(node: Node): NodeArray<Node>;
     function isToken(n: Node): boolean;
+    function isWord(kind: SyntaxKind): boolean;
     function isComment(kind: SyntaxKind): boolean;
     function isPunctuation(kind: SyntaxKind): boolean;
     function isInsideTemplateLiteral(node: LiteralExpression, position: number): boolean;
+    function isAccessibilityModifier(kind: SyntaxKind): boolean;
     function compareDataObjects(dst: any, src: any): boolean;
 }
 declare module "typescript" {
@@ -333,6 +389,7 @@ declare module "typescript" {
     function keywordPart(kind: SyntaxKind): SymbolDisplayPart;
     function punctuationPart(kind: SyntaxKind): SymbolDisplayPart;
     function operatorPart(kind: SyntaxKind): SymbolDisplayPart;
+    function textOrKeywordPart(text: string): SymbolDisplayPart;
     function textPart(text: string): SymbolDisplayPart;
     function lineBreakPart(): SymbolDisplayPart;
     function mapToDisplayParts(writeDisplayParts: (writer: DisplayPartsSymbolWriter) => void): SymbolDisplayPart[];

doc/spec.md

@@ -545,7 +545,7 @@ class CheckingAccount extends BankAccount {
 }
 ```
 
-In this example, the class 'CheckingAccount' *derives* from class 'BankAccount'. The constructor for 'CheckingAccount' calls the constructor for class 'BankAccount' using the 'super' keyword. In the emitted JavaScript code, the prototype of 'CheckingAccount' will chain to the prototype of 'BankingAccount'. 
+In this example, the class 'CheckingAccount' *derives* from class 'BankAccount'. The constructor for 'CheckingAccount' calls the constructor for class 'BankAccount' using the 'super' keyword. In the emitted JavaScript code, the prototype of 'CheckingAccount' will chain to the prototype of 'BankAccount'. 
 
 TypeScript classes may also specify static members. Static class members become properties of the class constructor. 
 

src/compiler/binder.ts

@@ -168,7 +168,7 @@ module ts {
             addDeclarationToSymbol(symbol, node, includes);
             symbol.parent = parent;
 
-            if (node.kind === SyntaxKind.ClassDeclaration && symbol.exports) {
+            if ((node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression) && symbol.exports) {
                 // TypeScript 1.0 spec (April 2014): 8.4
                 // Every class automatically contains a static property member named 'prototype', 
                 // the type of which is an instantiation of the class type with type Any supplied as a type argument for each type parameter.
@@ -286,6 +286,7 @@ module ts {
                 case SyntaxKind.ArrowFunction:
                     declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes);
                     break;
+                case SyntaxKind.ClassExpression:
                 case SyntaxKind.ClassDeclaration:
                     if (node.flags & NodeFlags.Static) {
                         declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes);
@@ -485,6 +486,9 @@ module ts {
                 case SyntaxKind.ArrowFunction:
                     bindAnonymousDeclaration(<FunctionExpression>node, SymbolFlags.Function, "__function", /*isBlockScopeContainer*/ true);
                     break;
+                case SyntaxKind.ClassExpression:
+                    bindAnonymousDeclaration(<ClassExpression>node, SymbolFlags.Class, "__class", /*isBlockScopeContainer*/ false);
+                    break;
                 case SyntaxKind.CatchClause:
                     bindCatchVariableDeclaration(<CatchClause>node);
                     break;
@@ -584,9 +588,9 @@ module ts {
             // containing class.
             if (node.flags & NodeFlags.AccessibilityModifier &&
                 node.parent.kind === SyntaxKind.Constructor &&
-                node.parent.parent.kind === SyntaxKind.ClassDeclaration) {
+                (node.parent.parent.kind === SyntaxKind.ClassDeclaration || node.parent.parent.kind === SyntaxKind.ClassExpression)) {
 
-                let classDeclaration = <ClassDeclaration>node.parent.parent;
+                let classDeclaration = <ClassLikeDeclaration>node.parent.parent;
                 declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes);
             }
         }

src/compiler/checker.ts

@@ -349,6 +349,14 @@ module ts {
                             }
                             result = undefined;
                         }
+                        else if (location.kind === SyntaxKind.SourceFile) {
+                            result = getSymbol(getSymbolOfNode(location).exports, "default", meaning & SymbolFlags.ModuleMember);
+                            let localSymbol = getLocalSymbolForExportDefault(result);
+                            if (result && (result.flags & meaning) && localSymbol && localSymbol.name === name) {
+                                break loop;
+                            }
+                            result = undefined;
+                        }
                         break;
                     case SyntaxKind.EnumDeclaration:
                         if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & SymbolFlags.EnumMember)) {
@@ -422,8 +430,15 @@ module ts {
                             result = argumentsSymbol;
                             break loop;
                         }
-                        let id = (<FunctionExpression>location).name;
-                        if (id && name === id.text) {
+                        let functionName = (<FunctionExpression>location).name;
+                        if (functionName && name === functionName.text) {
+                            result = location.symbol;
+                            break loop;
+                        }
+                        break;
+                    case SyntaxKind.ClassExpression:
+                        let className = (<ClassExpression>location).name;
+                        if (className && name === className.text) {
                             result = location.symbol;
                             break loop;
                         }
@@ -582,7 +597,7 @@ module ts {
             if (moduleSymbol.flags & SymbolFlags.Variable) {
                 let typeAnnotation = (<VariableDeclaration>moduleSymbol.valueDeclaration).type;
                 if (typeAnnotation) {
-                    return getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name);
+                    return getPropertyOfType(getTypeFromTypeNodeOrHeritageClauseElement(typeAnnotation), name);
                 }
             }
         }
@@ -631,7 +646,7 @@ module ts {
             if (symbol.flags & SymbolFlags.Variable) {
                 var typeAnnotation = (<VariableDeclaration>symbol.valueDeclaration).type;
                 if (typeAnnotation) {
-                    return resolveSymbol(getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name));
+                    return resolveSymbol(getPropertyOfType(getTypeFromTypeNodeOrHeritageClauseElement(typeAnnotation), name));
                 }
             }
         }
@@ -713,8 +728,14 @@ module ts {
         function markExportAsReferenced(node: ImportEqualsDeclaration | ExportAssignment | ExportSpecifier) {
             let symbol = getSymbolOfNode(node);
             let target = resolveAlias(symbol);
-            if (target && target !== unknownSymbol && target.flags & SymbolFlags.Value && !isConstEnumOrConstEnumOnlyModule(target)) {
-                markAliasSymbolAsReferenced(symbol);
+            if (target) {
+                let markAlias =
+                    (target === unknownSymbol && compilerOptions.separateCompilation) ||
+                    (target !== unknownSymbol && (target.flags & SymbolFlags.Value) && !isConstEnumOrConstEnumOnlyModule(target));
+
+                if (markAlias) {
+                    markAliasSymbolAsReferenced(symbol);
+                }
             }
         }
 
@@ -773,8 +794,8 @@ module ts {
         }
 
         // Resolves a qualified name and any involved aliases
-        function resolveEntityName(name: EntityName, meaning: SymbolFlags): Symbol {
-            if (getFullWidth(name) === 0) {
+        function resolveEntityName(name: EntityName | Expression, meaning: SymbolFlags): Symbol {
+            if (nodeIsMissing(name)) {
                 return undefined;
             }
 
@@ -785,18 +806,23 @@ module ts {
                     return undefined;
                 }
             }
-            else if (name.kind === SyntaxKind.QualifiedName) {
-                let namespace = resolveEntityName((<QualifiedName>name).left, SymbolFlags.Namespace);
-                if (!namespace || namespace === unknownSymbol || getFullWidth((<QualifiedName>name).right) === 0) {
+            else if (name.kind === SyntaxKind.QualifiedName || name.kind === SyntaxKind.PropertyAccessExpression) {
+                let left = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).left : (<PropertyAccessExpression>name).expression;
+                let right = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).right : (<PropertyAccessExpression>name).name;
+
+                let namespace = resolveEntityName(left, SymbolFlags.Namespace);
+                if (!namespace || namespace === unknownSymbol || nodeIsMissing(right)) {
                     return undefined;
                 }
-                let right = (<QualifiedName>name).right;
                 symbol = getSymbol(getExportsOfSymbol(namespace), right.text, meaning);
                 if (!symbol) {
                     error(right, Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(namespace), declarationNameToString(right));
                     return undefined;
                 }
             }
+            else {
+                Debug.fail("Unknown entity name kind.");
+            }
             Debug.assert((symbol.flags & SymbolFlags.Instantiated) === 0, "Should never get an instantiated symbol here.");
             return symbol.flags & meaning ? symbol : resolveAlias(symbol);
         }
@@ -1095,7 +1121,7 @@ module ts {
 
                 // Check if symbol is any of the alias
                 return forEachValue(symbols, symbolFromSymbolTable => {
-                    if (symbolFromSymbolTable.flags & SymbolFlags.Alias) {
+                    if (symbolFromSymbolTable.flags & SymbolFlags.Alias && symbolFromSymbolTable.name !== "export=") {
                         if (!useOnlyExternalAliasing || // We can use any type of alias to get the name
                             // Is this external alias, then use it to name
                             ts.forEach(symbolFromSymbolTable.declarations, isExternalModuleImportEqualsDeclaration)) {
@@ -1259,14 +1285,14 @@ module ts {
             }
         }
 
-        function isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult {
+        function isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult {
             // get symbol of the first identifier of the entityName
             let meaning: SymbolFlags;
             if (entityName.parent.kind === SyntaxKind.TypeQuery) {
                 // Typeof value
                 meaning = SymbolFlags.Value | SymbolFlags.ExportValue;
             }
-            else if (entityName.kind === SyntaxKind.QualifiedName ||
+            else if (entityName.kind === SyntaxKind.QualifiedName || entityName.kind === SyntaxKind.PropertyAccessExpression ||
                 entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration) {
                 // Left identifier from type reference or TypeAlias
                 // Entity name of the import declaration
@@ -1936,6 +1962,10 @@ module ts {
                     case SyntaxKind.SourceFile:
                         return true;
 
+                    // Export assignements do not create name bindings outside the module
+                    case SyntaxKind.ExportAssignment:
+                        return false;
+
                     default:
                         Debug.fail("isDeclarationVisible unknown: SyntaxKind: " + node.kind);
                 }
@@ -2092,7 +2122,7 @@ module ts {
             }
             // Use type from type annotation if one is present
             if (declaration.type) {
-                return getTypeFromTypeNode(declaration.type);
+                return getTypeFromTypeNodeOrHeritageClauseElement(declaration.type);
             }
             if (declaration.kind === SyntaxKind.Parameter) {
                 let func = <FunctionLikeDeclaration>declaration.parent;
@@ -2229,7 +2259,7 @@ module ts {
                         return links.type = checkExpression(exportAssignment.expression);
                     }
                     else if (exportAssignment.type) {
-                        return links.type = getTypeFromTypeNode(exportAssignment.type);
+                        return links.type = getTypeFromTypeNodeOrHeritageClauseElement(exportAssignment.type);
                     }
                     else {
                         return links.type = anyType;
@@ -2261,11 +2291,11 @@ module ts {
         function getAnnotatedAccessorType(accessor: AccessorDeclaration): Type {
             if (accessor) {
                 if (accessor.kind === SyntaxKind.GetAccessor) {
-                    return accessor.type && getTypeFromTypeNode(accessor.type);
+                    return accessor.type && getTypeFromTypeNodeOrHeritageClauseElement(accessor.type);
                 }
                 else {
                     let setterTypeAnnotation = getSetAccessorTypeAnnotationNode(accessor);
-                    return setterTypeAnnotation && getTypeFromTypeNode(setterTypeAnnotation);
+                    return setterTypeAnnotation && getTypeFromTypeNodeOrHeritageClauseElement(setterTypeAnnotation);
                 }
             }
             return undefined;
@@ -2431,9 +2461,9 @@ module ts {
                 }
                 type.baseTypes = [];
                 let declaration = <ClassDeclaration>getDeclarationOfKind(symbol, SyntaxKind.ClassDeclaration);
-                let baseTypeNode = getClassBaseTypeNode(declaration);
+                let baseTypeNode = getClassExtendsHeritageClauseElement(declaration);
                 if (baseTypeNode) {
-                    let baseType = getTypeFromTypeReferenceNode(baseTypeNode);
+                    let baseType = getTypeFromHeritageClauseElement(baseTypeNode);
                     if (baseType !== unknownType) {
                         if (getTargetType(baseType).flags & TypeFlags.Class) {
                             if (type !== baseType && !hasBaseType(<InterfaceType>baseType, type)) {
@@ -2474,7 +2504,8 @@ module ts {
                 forEach(symbol.declarations, declaration => {
                     if (declaration.kind === SyntaxKind.InterfaceDeclaration && getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration)) {
                         forEach(getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration), node => {
-                            let baseType = getTypeFromTypeReferenceNode(node);
+                            let baseType = getTypeFromHeritageClauseElement(node);
+
                             if (baseType !== unknownType) {
                                 if (getTargetType(baseType).flags & (TypeFlags.Class | TypeFlags.Interface)) {
                                     if (type !== baseType && !hasBaseType(<InterfaceType>baseType, type)) {
@@ -2505,7 +2536,7 @@ module ts {
             if (!links.declaredType) {
                 links.declaredType = resolvingType;
                 let declaration = <TypeAliasDeclaration>getDeclarationOfKind(symbol, SyntaxKind.TypeAliasDeclaration);
-                let type = getTypeFromTypeNode(declaration.type);
+                let type = getTypeFromTypeNodeOrHeritageClauseElement(declaration.type);
                 if (links.declaredType === resolvingType) {
                     links.declaredType = type;
                 }
@@ -3036,7 +3067,7 @@ module ts {
                     returnType = classType;
                 }
                 else if (declaration.type) {
-                    returnType = getTypeFromTypeNode(declaration.type);
+                    returnType = getTypeFromTypeNodeOrHeritageClauseElement(declaration.type);
                 }
                 else {
                     // TypeScript 1.0 spec (April 2014):
@@ -3194,7 +3225,7 @@ module ts {
         function getIndexTypeOfSymbol(symbol: Symbol, kind: IndexKind): Type {
             let declaration = getIndexDeclarationOfSymbol(symbol, kind);
             return declaration
-                ? declaration.type ? getTypeFromTypeNode(declaration.type) : anyType
+                ? declaration.type ? getTypeFromTypeNodeOrHeritageClauseElement(declaration.type) : anyType
                 : undefined;
         }
 
@@ -3205,7 +3236,7 @@ module ts {
                     type.constraint = targetConstraint ? instantiateType(targetConstraint, type.mapper) : noConstraintType;
                 }
                 else {
-                    type.constraint = getTypeFromTypeNode((<TypeParameterDeclaration>getDeclarationOfKind(type.symbol, SyntaxKind.TypeParameter)).constraint);
+                    type.constraint = getTypeFromTypeNodeOrHeritageClauseElement((<TypeParameterDeclaration>getDeclarationOfKind(type.symbol, SyntaxKind.TypeParameter)).constraint);
                 }
             }
             return type.constraint === noConstraintType ? undefined : type.constraint;
@@ -3253,7 +3284,7 @@ module ts {
             return type;
         }
 
-        function isTypeParameterReferenceIllegalInConstraint(typeReferenceNode: TypeReferenceNode, typeParameterSymbol: Symbol): boolean {
+        function isTypeParameterReferenceIllegalInConstraint(typeReferenceNode: TypeReferenceNode | HeritageClauseElement, typeParameterSymbol: Symbol): boolean {
             let links = getNodeLinks(typeReferenceNode);
             if (links.isIllegalTypeReferenceInConstraint !== undefined) {
                 return links.isIllegalTypeReferenceInConstraint;
@@ -3302,39 +3333,57 @@ module ts {
             }
         }
 
-        function getTypeFromTypeReferenceNode(node: TypeReferenceNode): Type {
+        function getTypeFromTypeReference(node: TypeReferenceNode): Type {
+            return getTypeFromTypeReferenceOrHeritageClauseElement(node);
+        }
+
+        function getTypeFromHeritageClauseElement(node: HeritageClauseElement): Type {
+            return getTypeFromTypeReferenceOrHeritageClauseElement(node);
+        }
+
+        function getTypeFromTypeReferenceOrHeritageClauseElement(node: TypeReferenceNode | HeritageClauseElement): Type {
             let links = getNodeLinks(node);
             if (!links.resolvedType) {
-                let symbol = resolveEntityName(node.typeName, SymbolFlags.Type);
                 let type: Type;
-                if (symbol) {
-                    if ((symbol.flags & SymbolFlags.TypeParameter) && isTypeParameterReferenceIllegalInConstraint(node, symbol)) {
-                        // TypeScript 1.0 spec (April 2014): 3.4.1
-                        // Type parameters declared in a particular type parameter list
-                        // may not be referenced in constraints in that type parameter list
-                        // Implementation: such type references are resolved to 'unknown' type that usually denotes error
-                        type = unknownType;
-                    }
-                    else {
-                        type = getDeclaredTypeOfSymbol(symbol);
-                        if (type.flags & (TypeFlags.Class | TypeFlags.Interface) && type.flags & TypeFlags.Reference) {
-                            let typeParameters = (<InterfaceType>type).typeParameters;
-                            if (node.typeArguments && node.typeArguments.length === typeParameters.length) {
-                                type = createTypeReference(<GenericType>type, map(node.typeArguments, getTypeFromTypeNode));
-                            }
-                            else {
-                                error(node, Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType), typeParameters.length);
-                                type = undefined;
-                            }
+
+                // We don't currently support heritage clauses with complex expressions in them.
+                // For these cases, we just set the type to be the unknownType.
+                if (node.kind !== SyntaxKind.HeritageClauseElement || isSupportedHeritageClauseElement(<HeritageClauseElement>node)) {
+                    let typeNameOrExpression = node.kind === SyntaxKind.TypeReference
+                        ? (<TypeReferenceNode>node).typeName
+                        : (<HeritageClauseElement>node).expression;
+
+                    let symbol = resolveEntityName(typeNameOrExpression, SymbolFlags.Type);
+                    if (symbol) {
+                        if ((symbol.flags & SymbolFlags.TypeParameter) && isTypeParameterReferenceIllegalInConstraint(node, symbol)) {
+                            // TypeScript 1.0 spec (April 2014): 3.4.1
+                            // Type parameters declared in a particular type parameter list
+                            // may not be referenced in constraints in that type parameter list
+                            // Implementation: such type references are resolved to 'unknown' type that usually denotes error
+                            type = unknownType;
                         }
                         else {
-                            if (node.typeArguments) {
-                                error(node, Diagnostics.Type_0_is_not_generic, typeToString(type));
-                                type = undefined;
+                            type = getDeclaredTypeOfSymbol(symbol);
+                            if (type.flags & (TypeFlags.Class | TypeFlags.Interface) && type.flags & TypeFlags.Reference) {
+                                let typeParameters = (<InterfaceType>type).typeParameters;
+                                if (node.typeArguments && node.typeArguments.length === typeParameters.length) {
+                                    type = createTypeReference(<GenericType>type, map(node.typeArguments, getTypeFromTypeNodeOrHeritageClauseElement));
+                                }
+                                else {
+                                    error(node, Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType), typeParameters.length);
+                                    type = undefined;
+                                }
+                            }
+                            else {
+                                if (node.typeArguments) {
+                                    error(node, Diagnostics.Type_0_is_not_generic, typeToString(type));
+                                    type = undefined;
+                                }
                             }
                         }
                     }
                 }
+
                 links.resolvedType = type || unknownType;
             }
             return links.resolvedType;
@@ -3412,7 +3461,7 @@ module ts {
         function getTypeFromArrayTypeNode(node: ArrayTypeNode): Type {
             let links = getNodeLinks(node);
             if (!links.resolvedType) {
-                links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType));
+                links.resolvedType = createArrayType(getTypeFromTypeNodeOrHeritageClauseElement(node.elementType));
             }
             return links.resolvedType;
         }
@@ -3430,7 +3479,7 @@ module ts {
         function getTypeFromTupleTypeNode(node: TupleTypeNode): Type {
             let links = getNodeLinks(node);
             if (!links.resolvedType) {
-                links.resolvedType = createTupleType(map(node.elementTypes, getTypeFromTypeNode));
+                links.resolvedType = createTupleType(map(node.elementTypes, getTypeFromTypeNodeOrHeritageClauseElement));
             }
             return links.resolvedType;
         }
@@ -3526,7 +3575,7 @@ module ts {
         function getTypeFromUnionTypeNode(node: UnionTypeNode): Type {
             let links = getNodeLinks(node);
             if (!links.resolvedType) {
-                links.resolvedType = getUnionType(map(node.types, getTypeFromTypeNode), /*noSubtypeReduction*/ true);
+                links.resolvedType = getUnionType(map(node.types, getTypeFromTypeNodeOrHeritageClauseElement), /*noSubtypeReduction*/ true);
             }
             return links.resolvedType;
         }
@@ -3558,7 +3607,7 @@ module ts {
             return links.resolvedType;
         }
 
-        function getTypeFromTypeNode(node: TypeNode | LiteralExpression): Type {
+        function getTypeFromTypeNodeOrHeritageClauseElement(node: TypeNode | LiteralExpression | HeritageClauseElement): Type {
             switch (node.kind) {
                 case SyntaxKind.AnyKeyword:
                     return anyType;
@@ -3575,7 +3624,9 @@ module ts {
                 case SyntaxKind.StringLiteral:
                     return getTypeFromStringLiteral(<LiteralExpression>node);
                 case SyntaxKind.TypeReference:
-                    return getTypeFromTypeReferenceNode(<TypeReferenceNode>node);
+                    return getTypeFromTypeReference(<TypeReferenceNode>node);
+                case SyntaxKind.HeritageClauseElement:
+                    return getTypeFromHeritageClauseElement(<HeritageClauseElement>node);
                 case SyntaxKind.TypeQuery:
                     return getTypeFromTypeQueryNode(<TypeQueryNode>node);
                 case SyntaxKind.ArrayType:
@@ -3585,7 +3636,7 @@ module ts {
                 case SyntaxKind.UnionType:
                     return getTypeFromUnionTypeNode(<UnionTypeNode>node);
                 case SyntaxKind.ParenthesizedType:
-                    return getTypeFromTypeNode((<ParenthesizedTypeNode>node).type);
+                    return getTypeFromTypeNodeOrHeritageClauseElement((<ParenthesizedTypeNode>node).type);
                 case SyntaxKind.FunctionType:
                 case SyntaxKind.ConstructorType:
                 case SyntaxKind.TypeLiteral:
@@ -4948,7 +4999,7 @@ module ts {
         function getResolvedSymbol(node: Identifier): Symbol {
             let links = getNodeLinks(node);
             if (!links.resolvedSymbol) {
-                links.resolvedSymbol = (getFullWidth(node) > 0 && resolveName(node, node.text, SymbolFlags.Value | SymbolFlags.ExportValue, Diagnostics.Cannot_find_name_0, node)) || unknownSymbol;
+                links.resolvedSymbol = (!nodeIsMissing(node) && resolveName(node, node.text, SymbolFlags.Value | SymbolFlags.ExportValue, Diagnostics.Cannot_find_name_0, node)) || unknownSymbol;
             }
             return links.resolvedSymbol;
         }
@@ -5454,7 +5505,7 @@ module ts {
             let isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).expression === node;
             let enclosingClass = <ClassDeclaration>getAncestor(node, SyntaxKind.ClassDeclaration);
             let baseClass: Type;
-            if (enclosingClass && getClassBaseTypeNode(enclosingClass)) {
+            if (enclosingClass && getClassExtendsHeritageClauseElement(enclosingClass)) {
                 let classType = <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClass));
                 baseClass = classType.baseTypes.length && classType.baseTypes[0];
             }
@@ -5586,7 +5637,7 @@ module ts {
             let declaration = <VariableLikeDeclaration>node.parent;
             if (node === declaration.initializer) {
                 if (declaration.type) {
-                    return getTypeFromTypeNode(declaration.type);
+                    return getTypeFromTypeNodeOrHeritageClauseElement(declaration.type);
                 }
                 if (declaration.kind === SyntaxKind.Parameter) {
                     let type = getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
@@ -5789,7 +5840,7 @@ module ts {
                 case SyntaxKind.NewExpression:
                     return getContextualTypeForArgument(<CallExpression>parent, node);
                 case SyntaxKind.TypeAssertionExpression:
-                    return getTypeFromTypeNode((<TypeAssertion>parent).type);
+                    return getTypeFromTypeNodeOrHeritageClauseElement((<TypeAssertion>parent).type);
                 case SyntaxKind.BinaryExpression:
                     return getContextualTypeForBinaryOperand(node);
                 case SyntaxKind.PropertyAssignment:
@@ -6446,7 +6497,7 @@ module ts {
                     let templateExpression = <TemplateExpression>tagExpression.template;
                     let lastSpan = lastOrUndefined(templateExpression.templateSpans);
                     Debug.assert(lastSpan !== undefined); // we should always have at least one span.
-                    callIsIncomplete = getFullWidth(lastSpan.literal) === 0 || !!lastSpan.literal.isUnterminated;
+                    callIsIncomplete = nodeIsMissing(lastSpan.literal) || !!lastSpan.literal.isUnterminated;
                 }
                 else {
                     // If the template didn't end in a backtick, or its beginning occurred right prior to EOF,
@@ -6590,7 +6641,7 @@ module ts {
             let typeArgumentsAreAssignable = true;
             for (let i = 0; i < typeParameters.length; i++) {
                 let typeArgNode = typeArguments[i];
-                let typeArgument = getTypeFromTypeNode(typeArgNode);
+                let typeArgument = getTypeFromTypeNodeOrHeritageClauseElement(typeArgNode);
                 // Do not push on this array! It has a preallocated length
                 typeArgumentResultTypes[i] = typeArgument;
                 if (typeArgumentsAreAssignable /* so far */) {
@@ -6664,7 +6715,7 @@ module ts {
         function getEffectiveTypeArguments(callExpression: CallExpression): TypeNode[] {
             if (callExpression.expression.kind === SyntaxKind.SuperKeyword) {
                 let containingClass = <ClassDeclaration>getAncestor(callExpression, SyntaxKind.ClassDeclaration);
-                let baseClassTypeNode = containingClass && getClassBaseTypeNode(containingClass);
+                let baseClassTypeNode = containingClass && getClassExtendsHeritageClauseElement(containingClass);
                 return baseClassTypeNode && baseClassTypeNode.typeArguments;
             }
             else {
@@ -7072,7 +7123,7 @@ module ts {
 
         function checkTypeAssertion(node: TypeAssertion): Type {
             let exprType = checkExpression(node.expression);
-            let targetType = getTypeFromTypeNode(node.type);
+            let targetType = getTypeFromTypeNodeOrHeritageClauseElement(node.type);
             if (produceDiagnostics && targetType !== unknownType) {
                 let widenedType = getWidenedType(exprType);
                 if (!(isTypeAssignableTo(targetType, widenedType))) {
@@ -7251,7 +7302,7 @@ module ts {
         function checkFunctionExpressionOrObjectLiteralMethodBody(node: FunctionExpression | MethodDeclaration) {
             Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node));
             if (node.type) {
-                checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type));
+                checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNodeOrHeritageClauseElement(node.type));
             }
 
             if (node.body) {
@@ -7261,7 +7312,7 @@ module ts {
                 else {
                     let exprType = checkExpression(<Expression>node.body);
                     if (node.type) {
-                        checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), node.body, /*headMessage*/ undefined);
+                        checkTypeAssignableTo(exprType, getTypeFromTypeNodeOrHeritageClauseElement(node.type), node.body, /*headMessage*/ undefined);
                     }
                     checkFunctionExpressionBodies(node.body);
                 }
@@ -7341,23 +7392,6 @@ module ts {
                 }
             }
 
-            function isImportedNameFromExternalModule(n: Node): boolean {
-                switch (n.kind) {
-                    case SyntaxKind.ElementAccessExpression:
-                    case SyntaxKind.PropertyAccessExpression: {
-                        // all bindings for external module should be immutable
-                        // so attempt to use a.b or a[b] as lhs will always fail
-                        // no matter what b is
-                        let symbol = findSymbol((<PropertyAccessExpression | ElementAccessExpression>n).expression);
-                        return symbol && symbol.flags & SymbolFlags.Alias && isExternalModuleSymbol(resolveAlias(symbol));
-                    }
-                    case SyntaxKind.ParenthesizedExpression:
-                        return isImportedNameFromExternalModule((<ParenthesizedExpression>n).expression);
-                    default:
-                        return false;
-                }
-            }
-
             if (!isReferenceOrErrorExpression(n)) {
                 error(n, invalidReferenceMessage);
                 return false;
@@ -7368,10 +7402,6 @@ module ts {
                 return false;
             }
 
-            if (isImportedNameFromExternalModule(n)) {
-                error(n, invalidReferenceMessage);
-            }
-
             return true;
         }
 
@@ -7967,6 +7997,8 @@ module ts {
                     return checkTypeAssertion(<TypeAssertion>node);
                 case SyntaxKind.ParenthesizedExpression:
                     return checkExpression((<ParenthesizedExpression>node).expression, contextualMapper);
+                case SyntaxKind.ClassExpression:
+                    return checkClassExpression(<ClassExpression>node);
                 case SyntaxKind.FunctionExpression:
                 case SyntaxKind.ArrowFunction:
                     return checkFunctionExpressionOrObjectLiteralMethod(<FunctionExpression>node, contextualMapper);
@@ -8194,7 +8226,7 @@ module ts {
             // TS 1.0 spec (April 2014): 8.3.2
             // Constructors of classes with no extends clause may not contain super calls, whereas
             // constructors of derived classes must contain at least one super call somewhere in their function body.
-            if (getClassBaseTypeNode(<ClassDeclaration>node.parent)) {
+            if (getClassExtendsHeritageClauseElement(<ClassDeclaration>node.parent)) {
 
                 if (containsSuperCall(node.body)) {
                     // The first statement in the body of a constructor must be a super call if both of the following are true:
@@ -8265,11 +8297,19 @@ module ts {
             checkDecorators(node);
         }
 
-        function checkTypeReference(node: TypeReferenceNode) {
+        function checkTypeReferenceNode(node: TypeReferenceNode) {
+            return checkTypeReferenceOrHeritageClauseElement(node);
+        }
+
+        function checkHeritageClauseElement(node: HeritageClauseElement) {
+            return checkTypeReferenceOrHeritageClauseElement(node);
+        }
+
+        function checkTypeReferenceOrHeritageClauseElement(node: TypeReferenceNode | HeritageClauseElement) {
             // Grammar checking
             checkGrammarTypeArguments(node, node.typeArguments);
 
-            let type = getTypeFromTypeReferenceNode(node);
+            let type = getTypeFromTypeReferenceOrHeritageClauseElement(node);
             if (type !== unknownType && node.typeArguments) {
                 // Do type argument local checks only if referenced type is successfully resolved
                 let len = node.typeArguments.length;
@@ -8437,7 +8477,7 @@ module ts {
             let isConstructor = (symbol.flags & SymbolFlags.Constructor) !== 0;
 
             function reportImplementationExpectedError(node: FunctionLikeDeclaration): void {
-                if (node.name && getFullWidth(node.name) === 0) {
+                if (node.name && nodeIsMissing(node.name)) {
                     return;
                 }
 
@@ -8760,7 +8800,7 @@ module ts {
 
             checkSourceElement(node.body);
             if (node.type && !isAccessor(node.kind)) {
-                checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type));
+                checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNodeOrHeritageClauseElement(node.type));
             }
 
             // Report an implicit any error if there is no body, no explicit return type, and node is not a private method
@@ -8860,7 +8900,7 @@ module ts {
                 return;
             }
 
-            if (getClassBaseTypeNode(enclosingClass)) {
+            if (getClassExtendsHeritageClauseElement(enclosingClass)) {
                 let isDeclaration = node.kind !== SyntaxKind.Identifier;
                 if (isDeclaration) {
                     error(node, Diagnostics.Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference);
@@ -9708,8 +9748,18 @@ module ts {
             }
         }
 
+        function checkClassExpression(node: ClassExpression): Type {
+            grammarErrorOnNode(node, Diagnostics.class_expressions_are_not_currently_supported);
+            forEach(node.members, checkSourceElement);
+            return unknownType;
+        }
+
         function checkClassDeclaration(node: ClassDeclaration) {
             // Grammar checking
+            if (node.parent.kind !== SyntaxKind.ModuleBlock && node.parent.kind !== SyntaxKind.SourceFile) {
+                grammarErrorOnNode(node, Diagnostics.class_declarations_are_only_supported_directly_inside_a_module_or_as_a_top_level_declaration);
+            }
+
             checkGrammarClassDeclarationHeritageClauses(node);
             checkDecorators(node);
             if (node.name) {
@@ -9722,10 +9772,14 @@ module ts {
             let symbol = getSymbolOfNode(node);
             let type = <InterfaceType>getDeclaredTypeOfSymbol(symbol);
             let staticType = <ObjectType>getTypeOfSymbol(symbol);
-            let baseTypeNode = getClassBaseTypeNode(node);
+            let baseTypeNode = getClassExtendsHeritageClauseElement(node);
             if (baseTypeNode) {
+                if (!isSupportedHeritageClauseElement(baseTypeNode)) {
+                    error(baseTypeNode.expression, Diagnostics.Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses);
+                }
+
                 emitExtends = emitExtends || !isInAmbientContext(node);
-                checkTypeReference(baseTypeNode);
+                checkHeritageClauseElement(baseTypeNode);
             }
             if (type.baseTypes.length) {
                 if (produceDiagnostics) {
@@ -9734,23 +9788,30 @@ module ts {
                     let staticBaseType = getTypeOfSymbol(baseType.symbol);
                     checkTypeAssignableTo(staticType, getTypeWithoutConstructors(staticBaseType), node.name || node,
                         Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
-                    if (baseType.symbol !== resolveEntityName(baseTypeNode.typeName, SymbolFlags.Value)) {
+
+                    if (baseType.symbol !== resolveEntityName(baseTypeNode.expression, SymbolFlags.Value)) {
                         error(baseTypeNode, Diagnostics.Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_0, typeToString(baseType));
                     }
 
                     checkKindsOfPropertyMemberOverrides(type, baseType);
                 }
-
-                // Check that base type can be evaluated as expression
-                checkExpressionOrQualifiedName(baseTypeNode.typeName);
             }
 
-            let implementedTypeNodes = getClassImplementedTypeNodes(node);
+            if (type.baseTypes.length || (baseTypeNode && compilerOptions.separateCompilation)) {
+                // Check that base type can be evaluated as expression
+                checkExpressionOrQualifiedName(baseTypeNode.expression);
+            }
+
+            let implementedTypeNodes = getClassImplementsHeritageClauseElements(node);
             if (implementedTypeNodes) {
                 forEach(implementedTypeNodes, typeRefNode => {
-                    checkTypeReference(typeRefNode);
+                    if (!isSupportedHeritageClauseElement(typeRefNode)) {
+                        error(typeRefNode.expression, Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
+                    }
+
+                    checkHeritageClauseElement(typeRefNode);
                     if (produceDiagnostics) {
-                        let t = getTypeFromTypeReferenceNode(typeRefNode);
+                        let t = getTypeFromHeritageClauseElement(typeRefNode);
                         if (t !== unknownType) {
                             let declaredType = (t.flags & TypeFlags.Reference) ? (<TypeReference>t).target : t;
                             if (declaredType.flags & (TypeFlags.Class | TypeFlags.Interface)) {
@@ -9872,7 +9933,7 @@ module ts {
                 if (!tp1.constraint || !tp2.constraint) {
                     return false;
                 }
-                if (!isTypeIdenticalTo(getTypeFromTypeNode(tp1.constraint), getTypeFromTypeNode(tp2.constraint))) {
+                if (!isTypeIdenticalTo(getTypeFromTypeNodeOrHeritageClauseElement(tp1.constraint), getTypeFromTypeNodeOrHeritageClauseElement(tp2.constraint))) {
                     return false;
                 }
             }
@@ -9943,7 +10004,13 @@ module ts {
                     }
                 }
             }
-            forEach(getInterfaceBaseTypeNodes(node), checkTypeReference);
+            forEach(getInterfaceBaseTypeNodes(node), heritageElement => {
+                if (!isSupportedHeritageClauseElement(heritageElement)) {
+                    error(heritageElement.expression, Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments);
+                }
+
+                checkHeritageClauseElement(heritageElement);
+            });
             forEach(node.members, checkSourceElement);
 
             if (produceDiagnostics) {
@@ -10144,6 +10211,11 @@ module ts {
 
             computeEnumMemberValues(node);
 
+            let enumIsConst = isConst(node);
+            if (compilerOptions.separateCompilation && enumIsConst && isInAmbientContext(node)) {
+                error(node.name, Diagnostics.Ambient_const_enums_are_not_allowed_when_the_separateCompilation_flag_is_provided);
+            }
+
             // Spec 2014 - Section 9.3:
             // It isn't possible for one enum declaration to continue the automatic numbering sequence of another,
             // and when an enum type has multiple declarations, only one declaration is permitted to omit a value
@@ -10154,7 +10226,6 @@ module ts {
             let firstDeclaration = getDeclarationOfKind(enumSymbol, node.kind);
             if (node === firstDeclaration) {
                 if (enumSymbol.declarations.length > 1) {
-                    let enumIsConst = isConst(node);
                     // check that const is placed\omitted on all enum declarations
                     forEach(enumSymbol.declarations, decl => {
                         if (isConstEnumDeclaration(decl) !== enumIsConst) {
@@ -10216,7 +10287,7 @@ module ts {
                 if (symbol.flags & SymbolFlags.ValueModule
                     && symbol.declarations.length > 1
                     && !isInAmbientContext(node)
-                    && isInstantiatedModule(node, compilerOptions.preserveConstEnums)) {
+                    && isInstantiatedModule(node, compilerOptions.preserveConstEnums || compilerOptions.separateCompilation)) {
                     let classOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol);
                     if (classOrFunc) {
                         if (getSourceFileOfNode(node) !== getSourceFileOfNode(classOrFunc)) {
@@ -10241,16 +10312,25 @@ module ts {
             checkSourceElement(node.body);
         }
 
-        function getFirstIdentifier(node: EntityName): Identifier {
-            while (node.kind === SyntaxKind.QualifiedName) {
-                node = (<QualifiedName>node).left;
+        function getFirstIdentifier(node: EntityName | Expression): Identifier {
+            while (true) {
+                if (node.kind === SyntaxKind.QualifiedName) {
+                    node = (<QualifiedName>node).left;
+                }
+                else if (node.kind === SyntaxKind.PropertyAccessExpression) {
+                    node = (<PropertyAccessExpression>node).expression;
+                }
+                else {
+                    break;
+                }
             }
+            Debug.assert(node.kind === SyntaxKind.Identifier);
             return <Identifier>node;
         }
 
         function checkExternalImportOrExportDeclaration(node: ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration): boolean {
             let moduleName = getExternalModuleName(node);
-            if (getFullWidth(moduleName) !== 0 && moduleName.kind !== SyntaxKind.StringLiteral) {
+            if (!nodeIsMissing(moduleName) && moduleName.kind !== SyntaxKind.StringLiteral) {
                 error(moduleName, Diagnostics.String_literal_expected);
                 return false;
             }
@@ -10471,7 +10551,7 @@ module ts {
                 case SyntaxKind.SetAccessor:
                     return checkAccessorDeclaration(<AccessorDeclaration>node);
                 case SyntaxKind.TypeReference:
-                    return checkTypeReference(<TypeReferenceNode>node);
+                    return checkTypeReferenceNode(<TypeReferenceNode>node);
                 case SyntaxKind.TypeQuery:
                     return checkTypeQuery(<TypeQueryNode>node);
                 case SyntaxKind.TypeLiteral:
@@ -10847,11 +10927,23 @@ module ts {
         // True if the given identifier is part of a type reference
         function isTypeReferenceIdentifier(entityName: EntityName): boolean {
             let node: Node = entityName;
-            while (node.parent && node.parent.kind === SyntaxKind.QualifiedName) node = node.parent;
+            while (node.parent && node.parent.kind === SyntaxKind.QualifiedName) {
+                node = node.parent;
+            }
+
             return node.parent && node.parent.kind === SyntaxKind.TypeReference;
         }
 
-        function isTypeNode(node: Node): boolean {
+        function isHeritageClauseElementIdentifier(entityName: Node): boolean {
+            let node = entityName;
+            while (node.parent && node.parent.kind === SyntaxKind.PropertyAccessExpression) {
+                node = node.parent;
+            }
+
+            return node.parent && node.parent.kind === SyntaxKind.HeritageClauseElement;
+        }
+
+        function isTypeNodeOrHeritageClauseElement(node: Node): boolean {
             if (SyntaxKind.FirstTypeNode <= node.kind && node.kind <= SyntaxKind.LastTypeNode) {
                 return true;
             }
@@ -10868,6 +10960,8 @@ module ts {
                 case SyntaxKind.StringLiteral:
                     // Specialized signatures can have string literals as their parameters' type names
                     return node.parent.kind === SyntaxKind.Parameter;
+                case SyntaxKind.HeritageClauseElement:
+                    return true;
 
                 // Identifiers and qualified names may be type nodes, depending on their context. Climb
                 // above them to find the lowest container
@@ -10876,10 +10970,15 @@ module ts {
                     if (node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node) {
                         node = node.parent;
                     }
+                    else if (node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node) {
+                        node = node.parent;
+                    }
                     // fall through
                 case SyntaxKind.QualifiedName:
+                case SyntaxKind.PropertyAccessExpression:
                     // At this point, node is either a qualified name or an identifier
-                    Debug.assert(node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName, "'node' was expected to be a qualified name or identifier in 'isTypeNode'.");
+                    Debug.assert(node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.PropertyAccessExpression,
+                        "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'.");
 
                     let parent = node.parent;
                     if (parent.kind === SyntaxKind.TypeQuery) {
@@ -10895,6 +10994,8 @@ module ts {
                         return true;
                     }
                     switch (parent.kind) {
+                        case SyntaxKind.HeritageClauseElement:
+                            return true;
                         case SyntaxKind.TypeParameter:
                             return node === (<TypeParameterDeclaration>parent).constraint;
                         case SyntaxKind.PropertyDeclaration:
@@ -10949,11 +11050,6 @@ module ts {
             return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined;
         }
 
-        function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) {
-            return (node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node) ||
-                (node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node);
-        }
-
         function getSymbolOfEntityNameOrPropertyAccessExpression(entityName: EntityName | PropertyAccessExpression): Symbol {
             if (isDeclarationName(entityName)) {
                 return getSymbolOfNode(entityName.parent);
@@ -10975,8 +11071,13 @@ module ts {
                 entityName = <QualifiedName | PropertyAccessExpression>entityName.parent;
             }
 
-            if (isExpression(entityName)) {
-                if (getFullWidth(entityName) === 0) {
+            if (isHeritageClauseElementIdentifier(<EntityName>entityName)) {
+                let meaning = entityName.parent.kind === SyntaxKind.HeritageClauseElement ? SymbolFlags.Type : SymbolFlags.Namespace;
+                meaning |= SymbolFlags.Alias;
+                return resolveEntityName(<EntityName>entityName, meaning);
+            }
+            else if (isExpression(entityName)) {
+                if (nodeIsMissing(entityName)) {
                     // Missing entity name.
                     return undefined;
                 }
@@ -11091,12 +11192,12 @@ module ts {
                 return unknownType;
             }
 
-            if (isExpression(node)) {
-                return getTypeOfExpression(<Expression>node);
+            if (isTypeNodeOrHeritageClauseElement(node)) {
+                return getTypeFromTypeNodeOrHeritageClauseElement(<TypeNode | HeritageClauseElement>node);
             }
 
-            if (isTypeNode(node)) {
-                return getTypeFromTypeNode(<TypeNode>node);
+            if (isExpression(node)) {
+                return getTypeOfExpression(<Expression>node);
             }
 
             if (isTypeDeclaration(node)) {
@@ -11259,13 +11360,18 @@ module ts {
                 // parent is not source file or it is not reference to internal module
                 return false;
             }
-            return isAliasResolvedToValue(getSymbolOfNode(node));
+
+            var isValue = isAliasResolvedToValue(getSymbolOfNode(node));
+            return isValue && node.moduleReference && !nodeIsMissing(node.moduleReference);
         }
 
         function isAliasResolvedToValue(symbol: Symbol): boolean {
             let target = resolveAlias(symbol);
+            if (target === unknownSymbol && compilerOptions.separateCompilation) {
+                return true;
+            }
             // const enums and modules that contain only const enums are not considered values from the emit perespective
-            return target !== unknownSymbol && target.flags & SymbolFlags.Value && !isConstEnumOrConstEnumOnlyModule(target);
+            return target !== unknownSymbol && target && target.flags & SymbolFlags.Value && !isConstEnumOrConstEnumOnlyModule(target);
         }
 
         function isConstEnumOrConstEnumOnlyModule(s: Symbol): boolean {
@@ -12166,9 +12272,6 @@ module ts {
         function checkGrammarVariableDeclaration(node: VariableDeclaration) {
             if (node.parent.parent.kind !== SyntaxKind.ForInStatement && node.parent.parent.kind !== SyntaxKind.ForOfStatement) {
                 if (isInAmbientContext(node)) {
-                    if (isBindingPattern(node.name)) {
-                        return grammarErrorOnNode(node, Diagnostics.Destructuring_declarations_are_not_allowed_in_ambient_contexts);
-                    }
                     if (node.initializer) {
                         // Error on equals token which immediate precedes the initializer
                         let equalsTokenLength = "=".length;

src/compiler/commandLineParser.ts

@@ -4,15 +4,12 @@
 /// <reference path="scanner.ts"/>
 
 module ts {
+    /* @internal */
     export var optionDeclarations: CommandLineOption[] = [
         {
             name: "charset",
             type: "string",
         },
-        {
-            name: "codepage",
-            type: "number",
-        },
         {
             name: "declaration",
             shortName: "d",
@@ -78,10 +75,6 @@ module ts {
             name: "noLib",
             type: "boolean",
         },
-        {
-            name: "noLibCheck",
-            type: "boolean",
-        },
         {
             name: "noResolve",
             type: "boolean",
@@ -117,6 +110,10 @@ module ts {
             type: "boolean",
             description: Diagnostics.Do_not_emit_comments_to_output,
         },
+        {
+            name: "separateCompilation",
+            type: "boolean",
+        },
         {
             name: "sourceMap",
             type: "boolean",
@@ -140,18 +137,6 @@ module ts {
             description: Diagnostics.Do_not_emit_declarations_for_code_that_has_an_internal_annotation,
             experimental: true
         },
-        {
-            name: "preserveNewLines",
-            type: "boolean",
-            description: Diagnostics.Preserve_new_lines_when_emitting_code,
-            experimental: true
-        },
-        {
-            name: "cacheDownlevelForOfLength",
-            type: "boolean",
-            description: "Cache length access when downlevel emitting for-of statements",
-            experimental: true,
-        },
         {
             name: "target",
             shortName: "t",
@@ -173,7 +158,8 @@ module ts {
             description: Diagnostics.Watch_input_files,
         }
     ];
-    
+
+    /* @internal */
     export function parseCommandLine(commandLine: string[]): ParsedCommandLine {
         var options: CompilerOptions = {};
         var fileNames: string[] = [];
@@ -283,6 +269,10 @@ module ts {
         }
     }
 
+    /**
+      * Read tsconfig.json file
+      * @param fileName The path to the config file
+      */
     export function readConfigFile(fileName: string): any {
         try {
             var text = sys.readFile(fileName);
@@ -292,6 +282,12 @@ module ts {
         }
     }
 
+    /**
+      * Parse the contents of a config file (tsconfig.json).
+      * @param json The contents of the config file to parse
+      * @param basePath A root directory to resolve relative path entries in the config
+      *    file to. e.g. outDir 
+      */
     export function parseConfigFile(json: any, basePath?: string): ParsedCommandLine {
         var errors: Diagnostic[] = [];
 

src/compiler/declarationEmitter.ts

@@ -314,12 +314,12 @@ module ts {
             }
         }
 
-        function emitTypeWithNewGetSymbolAccessibilityDiagnostic(type: TypeNode | EntityName, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) {
+        function emitTypeWithNewGetSymbolAccessibilityDiagnostic(type: TypeNode | EntityName | HeritageClauseElement, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) {
             writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic;
             emitType(type);
         }
 
-        function emitType(type: TypeNode | StringLiteralExpression | Identifier | QualifiedName) {
+        function emitType(type: TypeNode | StringLiteralExpression | Identifier | QualifiedName | HeritageClauseElement) {
             switch (type.kind) {
                 case SyntaxKind.AnyKeyword:
                 case SyntaxKind.StringKeyword:
@@ -329,6 +329,8 @@ module ts {
                 case SyntaxKind.VoidKeyword:
                 case SyntaxKind.StringLiteral:
                     return writeTextOfNode(currentSourceFile, type);
+                case SyntaxKind.HeritageClauseElement:
+                    return emitHeritageClauseElement(<HeritageClauseElement>type);
                 case SyntaxKind.TypeReference:
                     return emitTypeReference(<TypeReferenceNode>type);
                 case SyntaxKind.TypeQuery:
@@ -350,11 +352,9 @@ module ts {
                     return emitEntityName(<Identifier>type);
                 case SyntaxKind.QualifiedName:
                     return emitEntityName(<QualifiedName>type);
-                default:
-                    Debug.fail("Unknown type annotation: " + type.kind);
             }
 
-            function emitEntityName(entityName: EntityName) {
+            function emitEntityName(entityName: EntityName | PropertyAccessExpression) {
                 let visibilityResult = resolver.isEntityNameVisible(entityName,
                     // Aliases can be written asynchronously so use correct enclosing declaration
                     entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration ? entityName.parent : enclosingDeclaration);
@@ -362,15 +362,28 @@ module ts {
                 handleSymbolAccessibilityError(visibilityResult);
                 writeEntityName(entityName);
 
-                function writeEntityName(entityName: EntityName) {
+                function writeEntityName(entityName: EntityName | Expression) {
                     if (entityName.kind === SyntaxKind.Identifier) {
                         writeTextOfNode(currentSourceFile, entityName);
                     }
                     else {
-                        let qualifiedName = <QualifiedName>entityName;
-                        writeEntityName(qualifiedName.left);
+                        let left = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).left : (<PropertyAccessExpression>entityName).expression;
+                        let right = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).right : (<PropertyAccessExpression>entityName).name;
+                        writeEntityName(left);
                         write(".");
-                        writeTextOfNode(currentSourceFile, qualifiedName.right);
+                        writeTextOfNode(currentSourceFile, right);
+                    }
+                }
+            }
+
+            function emitHeritageClauseElement(node: HeritageClauseElement) {
+                if (isSupportedHeritageClauseElement(node)) {
+                    Debug.assert(node.expression.kind === SyntaxKind.Identifier || node.expression.kind === SyntaxKind.PropertyAccessExpression);
+                    emitEntityName(<Identifier | PropertyAccessExpression>node.expression);
+                    if (node.typeArguments) {
+                        write("<");
+                        emitCommaList(node.typeArguments, emitType);
+                        write(">");
                     }
                 }
             }
@@ -827,14 +840,16 @@ module ts {
             }
         }
 
-        function emitHeritageClause(typeReferences: TypeReferenceNode[], isImplementsList: boolean) {
+        function emitHeritageClause(typeReferences: HeritageClauseElement[], isImplementsList: boolean) {
             if (typeReferences) {
                 write(isImplementsList ? " implements " : " extends ");
                 emitCommaList(typeReferences, emitTypeOfTypeReference);
             }
 
-            function emitTypeOfTypeReference(node: TypeReferenceNode) {
-                emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError);
+            function emitTypeOfTypeReference(node: HeritageClauseElement) {
+                if (isSupportedHeritageClauseElement(node)) {
+                    emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError);
+                }
 
                 function getHeritageClauseVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
                     let diagnosticMessage: DiagnosticMessage;
@@ -877,11 +892,11 @@ module ts {
             let prevEnclosingDeclaration = enclosingDeclaration;
             enclosingDeclaration = node;
             emitTypeParameters(node.typeParameters);
-            let baseTypeNode = getClassBaseTypeNode(node);
+            let baseTypeNode = getClassExtendsHeritageClauseElement(node);
             if (baseTypeNode) {
                 emitHeritageClause([baseTypeNode], /*isImplementsList*/ false);
             }
-            emitHeritageClause(getClassImplementedTypeNodes(node), /*isImplementsList*/ true);
+            emitHeritageClause(getClassImplementsHeritageClauseElements(node), /*isImplementsList*/ true);
             write(" {");
             writeLine();
             increaseIndent();
@@ -993,7 +1008,18 @@ module ts {
             }
 
             function emitBindingPattern(bindingPattern: BindingPattern) {
-                emitCommaList(bindingPattern.elements, emitBindingElement);
+                // Only select non-omitted expression from the bindingPattern's elements.
+                // We have to do this to avoid emitting trailing commas.
+                // For example:
+                //      original: var [, c,,] = [ 2,3,4]
+                //      emitted: declare var c: number; // instead of declare var c:number, ;
+                let elements: Node[] = [];
+                for (let element of bindingPattern.elements) {
+                    if (element.kind !== SyntaxKind.OmittedExpression){
+                        elements.push(element);
+                    }
+                }
+                emitCommaList(elements, emitBindingElement);
             }
 
             function emitBindingElement(bindingElement: BindingElement) {
@@ -1291,7 +1317,10 @@ module ts {
                 write("...");
             }
             if (isBindingPattern(node.name)) {
-                write("_" + indexOf((<FunctionLikeDeclaration>node.parent).parameters, node));
+                // For bindingPattern, we can't simply writeTextOfNode from the source file
+                // because we want to omit the initializer and using writeTextOfNode will result in initializer get emitted.
+                // Therefore, we will have to recursively emit each element in the bindingPattern.
+                emitBindingPattern(<BindingPattern>node.name);
             }
             else {
                 writeTextOfNode(currentSourceFile, node.name);
@@ -1311,41 +1340,46 @@ module ts {
             }
 
             function getParameterDeclarationTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                let diagnosticMessage: DiagnosticMessage;
+                let diagnosticMessage: DiagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
+                return diagnosticMessage !== undefined ? {
+                    diagnosticMessage,
+                    errorNode: node,
+                    typeName: node.name
+                } : undefined;
+            }
+
+            function getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult: SymbolAccessiblityResult): DiagnosticMessage {
                 switch (node.parent.kind) {
                     case SyntaxKind.Constructor:
-                        diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
+                        return symbolAccesibilityResult.errorModuleName ?
                             symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
                                 Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
                                 Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
                             Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1;
-                        break;
 
                     case SyntaxKind.ConstructSignature:
                         // Interfaces cannot have parameter types that cannot be named
-                        diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
+                        return symbolAccesibilityResult.errorModuleName ?
                             Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
                             Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1;
-                        break;
 
                     case SyntaxKind.CallSignature:
                         // Interfaces cannot have parameter types that cannot be named
-                        diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
+                        return symbolAccesibilityResult.errorModuleName ?
                             Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
                             Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
-                        break;
 
                     case SyntaxKind.MethodDeclaration:
                     case SyntaxKind.MethodSignature:
                         if (node.parent.flags & NodeFlags.Static) {
-                            diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
+                            return symbolAccesibilityResult.errorModuleName ?
                                 symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
                                     Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
                                     Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
                                 Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
                         }
                         else if (node.parent.parent.kind === SyntaxKind.ClassDeclaration) {
-                            diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
+                             return symbolAccesibilityResult.errorModuleName ?
                                 symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
                                     Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
                                     Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
@@ -1353,30 +1387,99 @@ module ts {
                         }
                         else {
                             // Interfaces cannot have parameter types that cannot be named
-                            diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
+                            return symbolAccesibilityResult.errorModuleName ?
                                 Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
                                 Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1;
                         }
-                        break;
 
                     case SyntaxKind.FunctionDeclaration:
-                        diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
+                        return symbolAccesibilityResult.errorModuleName ?
                             symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
                                 Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
                                 Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 :
                             Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1;
-                        break;
 
                     default:
                         Debug.fail("This is unknown parent for parameter: " + node.parent.kind);
                 }
-
-                return {
-                    diagnosticMessage,
-                    errorNode: node,
-                    typeName: node.name
-                };
             }
+
+            function emitBindingPattern(bindingPattern: BindingPattern) {
+                // We have to explicitly emit square bracket and bracket because these tokens are not store inside the node.
+                if (bindingPattern.kind === SyntaxKind.ObjectBindingPattern) {
+                    write("{");
+                    emitCommaList(bindingPattern.elements, emitBindingElement);
+                    write("}");
+                }
+                else if (bindingPattern.kind === SyntaxKind.ArrayBindingPattern) {
+                    write("[");
+                    let elements = bindingPattern.elements;
+                    emitCommaList(elements, emitBindingElement);
+                    if (elements && elements.hasTrailingComma) {
+                        write(", ");
+                    }
+                    write("]");
+                }
+            }
+
+            function emitBindingElement(bindingElement: BindingElement) {
+                function getBindingElementTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
+                    let diagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
+                    return diagnosticMessage !== undefined ? {
+                        diagnosticMessage,
+                        errorNode: bindingElement,
+                        typeName: bindingElement.name
+                    } : undefined;
+                }
+
+                if (bindingElement.kind === SyntaxKind.OmittedExpression) {
+                    // If bindingElement is an omittedExpression (i.e. containing elision),
+                    // we will emit blank space (although this may differ from users' original code,
+                    // it allows emitSeparatedList to write separator appropriately)
+                    // Example:
+                    //      original: function foo([, x, ,]) {}
+                    //      emit    : function foo([ , x,  , ]) {}
+                    write(" ");
+                }
+                else if (bindingElement.kind === SyntaxKind.BindingElement) {
+                    if (bindingElement.propertyName) {
+                        // bindingElement has propertyName property in the following case:
+                        //      { y: [a,b,c] ...} -> bindingPattern will have a property called propertyName for "y"
+                        // We have to explicitly emit the propertyName before descending into its binding elements.
+                        // Example:
+                        //      original: function foo({y: [a,b,c]}) {}
+                        //      emit    : declare function foo({y: [a, b, c]}: { y: [any, any, any] }) void;
+                        writeTextOfNode(currentSourceFile, bindingElement.propertyName);
+                        write(": ");
+
+                        // If bindingElement has propertyName property, then its name must be another bindingPattern of SyntaxKind.ObjectBindingPattern
+                        emitBindingPattern(<BindingPattern>bindingElement.name);
+                    }
+                    else if (bindingElement.name) {
+                        if (isBindingPattern(bindingElement.name)) {
+                            // If it is a nested binding pattern, we will recursively descend into each element and emit each one separately.
+                            // In the case of rest element, we will omit rest element.
+                            // Example:
+                            //      original: function foo([a, [[b]], c] = [1,[["string"]], 3]) {}
+                            //      emit    : declare function foo([a, [[b]], c]: [number, [[string]], number]): void;
+                            //      original with rest: function foo([a, ...c]) {}
+                            //      emit              : declare function foo([a, ...c]): void;
+                            emitBindingPattern(<BindingPattern>bindingElement.name);
+                        }
+                        else {
+                            Debug.assert(bindingElement.name.kind === SyntaxKind.Identifier);
+                            // If the node is just an identifier, we will simply emit the text associated with the node's name
+                            // Example:
+                            //      original: function foo({y = 10, x}) {}
+                            //      emit    : declare function foo({y, x}: {number, any}): void;
+                            if (bindingElement.dotDotDotToken) {
+                                write("...");
+                            }
+                            writeTextOfNode(currentSourceFile, bindingElement.name);
+                        }
+                    }
+                }
+            } 
         }
 
         function emitNode(node: Node) {

src/compiler/diagnosticInformationMap.generated.ts

@@ -165,6 +165,8 @@ module ts {
         Decorators_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1205, category: DiagnosticCategory.Error, key: "Decorators are only available when targeting ECMAScript 5 and higher." },
         Decorators_are_not_valid_here: { code: 1206, category: DiagnosticCategory.Error, key: "Decorators are not valid here." },
         Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name: { code: 1207, category: DiagnosticCategory.Error, key: "Decorators cannot be applied to multiple get/set accessors of the same name." },
+        Cannot_compile_non_external_modules_when_the_separateCompilation_flag_is_provided: { code: 1208, category: DiagnosticCategory.Error, key: "Cannot compile non-external modules when the '--separateCompilation' flag is provided." },
+        Ambient_const_enums_are_not_allowed_when_the_separateCompilation_flag_is_provided: { code: 1209, category: DiagnosticCategory.Error, key: "Ambient const enums are not allowed when the '--separateCompilation' flag is provided." },
         Duplicate_identifier_0: { code: 2300, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." },
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: DiagnosticCategory.Error, key: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
         Static_members_cannot_reference_class_type_parameters: { code: 2302, category: DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." },
@@ -351,6 +353,8 @@ module ts {
         The_arguments_object_cannot_be_referenced_in_an_arrow_function_Consider_using_a_standard_function_expression: { code: 2496, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression." },
         External_module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct: { code: 2497, category: DiagnosticCategory.Error, key: "External module '{0}' resolves to a non-module entity and cannot be imported using this construct." },
         External_module_0_uses_export_and_cannot_be_used_with_export_Asterisk: { code: 2498, category: DiagnosticCategory.Error, key: "External module '{0}' uses 'export =' and cannot be used with 'export *'." },
+        An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2499, category: DiagnosticCategory.Error, key: "An interface can only extend an identifier/qualified-name with optional type arguments." },
+        A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2500, category: DiagnosticCategory.Error, key: "A class can only implement an identifier/qualified-name with optional type arguments." },
         Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." },
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." },
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." },
@@ -434,6 +438,11 @@ module ts {
         Option_noEmit_cannot_be_specified_with_option_out_or_outDir: { code: 5040, category: DiagnosticCategory.Error, key: "Option 'noEmit' cannot be specified with option 'out' or 'outDir'." },
         Option_noEmit_cannot_be_specified_with_option_declaration: { code: 5041, category: DiagnosticCategory.Error, key: "Option 'noEmit' cannot be specified with option 'declaration'." },
         Option_project_cannot_be_mixed_with_source_files_on_a_command_line: { code: 5042, category: DiagnosticCategory.Error, key: "Option 'project' cannot be mixed with source files on a command line." },
+        Option_sourceMap_cannot_be_specified_with_option_separateCompilation: { code: 5043, category: DiagnosticCategory.Error, key: "Option 'sourceMap' cannot be specified with option 'separateCompilation'." },
+        Option_declaration_cannot_be_specified_with_option_separateCompilation: { code: 5044, category: DiagnosticCategory.Error, key: "Option 'declaration' cannot be specified with option 'separateCompilation'." },
+        Option_noEmitOnError_cannot_be_specified_with_option_separateCompilation: { code: 5045, category: DiagnosticCategory.Error, key: "Option 'noEmitOnError' cannot be specified with option 'separateCompilation'." },
+        Option_out_cannot_be_specified_with_option_separateCompilation: { code: 5046, category: DiagnosticCategory.Error, key: "Option 'out' cannot be specified with option 'separateCompilation'." },
+        Option_separateCompilation_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES6_or_higher: { code: 5047, category: DiagnosticCategory.Error, key: "Option 'separateCompilation' can only be used when either option'--module' is provided or option 'target' is 'ES6' or higher." },
         Concatenate_and_emit_output_to_single_file: { code: 6001, category: DiagnosticCategory.Message, key: "Concatenate and emit output to single file." },
         Generates_corresponding_d_ts_file: { code: 6002, category: DiagnosticCategory.Message, key: "Generates corresponding '.d.ts' file." },
         Specifies_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: { code: 6003, category: DiagnosticCategory.Message, key: "Specifies the location where debugger should locate map files instead of generated locations." },
@@ -498,5 +507,8 @@ module ts {
         You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: { code: 8001, category: DiagnosticCategory.Error, key: "You cannot rename elements that are defined in the standard TypeScript library." },
         yield_expressions_are_not_currently_supported: { code: 9000, category: DiagnosticCategory.Error, key: "'yield' expressions are not currently supported." },
         Generators_are_not_currently_supported: { code: 9001, category: DiagnosticCategory.Error, key: "Generators are not currently supported." },
+        Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." },
+        class_expressions_are_not_currently_supported: { code: 9003, category: DiagnosticCategory.Error, key: "'class' expressions are not currently supported." },
+        class_declarations_are_only_supported_directly_inside_a_module_or_as_a_top_level_declaration: { code: 9004, category: DiagnosticCategory.Error, key: "'class' declarations are only supported directly inside a module or as a top level declaration." },
     };
 }

src/compiler/diagnosticMessages.json

@@ -651,7 +651,14 @@
         "category": "Error",
         "code": 1207
     },
-
+    "Cannot compile non-external modules when the '--separateCompilation' flag is provided.": {
+        "category": "Error",
+        "code": 1208
+    },
+    "Ambient const enums are not allowed when the '--separateCompilation' flag is provided.": {
+        "category": "Error",
+        "code": 1209
+    },
     "Duplicate identifier '{0}'.": {
         "category": "Error",
         "code": 2300
@@ -1396,6 +1403,14 @@
         "category": "Error",
         "code": 2498
     },
+    "An interface can only extend an identifier/qualified-name with optional type arguments.": {
+        "category": "Error",
+        "code": 2499
+    },
+    "A class can only implement an identifier/qualified-name with optional type arguments.": {
+        "category": "Error",
+        "code": 2500
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
@@ -1729,6 +1744,26 @@
         "category": "Error",
         "code": 5042
     },
+    "Option 'sourceMap' cannot be specified with option 'separateCompilation'.": {
+        "category": "Error",
+        "code": 5043
+    },
+    "Option 'declaration' cannot be specified with option 'separateCompilation'.": {
+        "category": "Error",
+        "code": 5044
+    },
+    "Option 'noEmitOnError' cannot be specified with option 'separateCompilation'.": {
+        "category": "Error",
+        "code": 5045
+    },
+    "Option 'out' cannot be specified with option 'separateCompilation'.": {
+        "category": "Error",
+        "code": 5046
+    },
+    "Option 'separateCompilation' can only be used when either option'--module' is provided or option 'target' is 'ES6' or higher.": {
+        "category": "Error",
+        "code": 5047
+    },
     "Concatenate and emit output to single file.": {
         "category": "Message",
         "code": 6001
@@ -1985,5 +2020,17 @@
     "Generators are not currently supported.": {
         "category": "Error",
         "code": 9001
+    },
+    "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.": {
+        "category": "Error",
+        "code": 9002
+    },
+    "'class' expressions are not currently supported.": {
+        "category": "Error",
+        "code": 9003
+    },
+    "'class' declarations are only supported directly inside a module or as a top level declaration.": {
+        "category": "Error",
+        "code": 9004
     }
 }

src/compiler/parser.ts

@@ -237,12 +237,13 @@ module ts {
             case SyntaxKind.Decorator:
                 return visitNode(cbNode, (<Decorator>node).expression);
             case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
                 return visitNodes(cbNodes, node.decorators) ||
                     visitNodes(cbNodes, node.modifiers) ||
-                    visitNode(cbNode, (<ClassDeclaration>node).name) ||
-                    visitNodes(cbNodes, (<ClassDeclaration>node).typeParameters) ||
-                    visitNodes(cbNodes, (<ClassDeclaration>node).heritageClauses) ||
-                    visitNodes(cbNodes, (<ClassDeclaration>node).members);
+                    visitNode(cbNode, (<ClassLikeDeclaration>node).name) ||
+                    visitNodes(cbNodes, (<ClassLikeDeclaration>node).typeParameters) ||
+                    visitNodes(cbNodes, (<ClassLikeDeclaration>node).heritageClauses) ||
+                    visitNodes(cbNodes, (<ClassLikeDeclaration>node).members);
             case SyntaxKind.InterfaceDeclaration:
                 return visitNodes(cbNodes, node.decorators) ||
                     visitNodes(cbNodes, node.modifiers) ||
@@ -308,6 +309,9 @@ module ts {
                 return visitNode(cbNode, (<ComputedPropertyName>node).expression);
             case SyntaxKind.HeritageClause:
                 return visitNodes(cbNodes, (<HeritageClause>node).types);
+            case SyntaxKind.HeritageClauseElement:
+                return visitNode(cbNode, (<HeritageClauseElement>node).expression) ||
+                    visitNodes(cbNodes, (<HeritageClauseElement>node).typeArguments);
             case SyntaxKind.ExternalModuleReference:
                 return visitNode(cbNode, (<ExternalModuleReference>node).expression);
             case SyntaxKind.MissingDeclaration:
@@ -324,7 +328,7 @@ module ts {
         TypeMembers,               // Members in interface or type literal
         ClassMembers,              // Members in class declaration
         EnumMembers,               // Members in enum declaration
-        TypeReferences,            // Type references in extends or implements clause
+        HeritageClauseElement,     // Elements in a heritage clause
         VariableDeclarations,      // Variable declarations in variable statement
         ObjectBindingElements,     // Binding elements in object binding list
         ArrayBindingElements,      // Binding elements in array binding list
@@ -356,7 +360,7 @@ module ts {
             case ParsingContext.TypeMembers:              return Diagnostics.Property_or_signature_expected;
             case ParsingContext.ClassMembers:             return Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected;
             case ParsingContext.EnumMembers:              return Diagnostics.Enum_member_expected;
-            case ParsingContext.TypeReferences:           return Diagnostics.Type_reference_expected;
+            case ParsingContext.HeritageClauseElement:    return Diagnostics.Expression_expected;
             case ParsingContext.VariableDeclarations:     return Diagnostics.Variable_declaration_expected;
             case ParsingContext.ObjectBindingElements:    return Diagnostics.Property_destructuring_pattern_expected;
             case ParsingContext.ArrayBindingElements:     return Diagnostics.Array_element_destructuring_pattern_expected;
@@ -1605,7 +1609,11 @@ module ts {
                 case ParsingContext.TypeMembers:
                     return isStartOfTypeMember();
                 case ParsingContext.ClassMembers:
-                    return lookAhead(isClassMemberStart);
+                    // We allow semicolons as class elements (as specified by ES6) as long as we're
+                    // not in error recovery.  If we're in error recovery, we don't want an errant
+                    // semicolon to be treated as a class member (since they're almost always used
+                    // for statements.
+                    return lookAhead(isClassMemberStart) || (token === SyntaxKind.SemicolonToken && !inErrorRecovery);
                 case ParsingContext.EnumMembers:
                     // Include open bracket computed properties. This technically also lets in indexers,
                     // which would be a candidate for improved error reporting.
@@ -1614,10 +1622,22 @@ module ts {
                     return token === SyntaxKind.OpenBracketToken || token === SyntaxKind.AsteriskToken || isLiteralPropertyName();
                 case ParsingContext.ObjectBindingElements:
                     return isLiteralPropertyName();
-                case ParsingContext.TypeReferences:
-                    // We want to make sure that the "extends" in "extends foo" or the "implements" in
-                    // "implements foo" is not considered a type name.
-                    return isIdentifier() && !isNotHeritageClauseTypeName();
+                case ParsingContext.HeritageClauseElement:
+                    // If we see { } then only consume it as an expression if it is followed by , or {
+                    // That way we won't consume the body of a class in its heritage clause.
+                    if (token === SyntaxKind.OpenBraceToken) {
+                        return lookAhead(isValidHeritageClauseObjectLiteral);
+                    }
+
+                    if (!inErrorRecovery) {
+                        return isStartOfLeftHandSideExpression() && !isHeritageClauseExtendsOrImplementsKeyword();
+                    }
+                    else {
+                        // If we're in error recovery we tighten up what we're willing to match.
+                        // That way we don't treat something like "this" as a valid heritage clause
+                        // element during recovery.
+                        return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword();
+                    }
                 case ParsingContext.VariableDeclarations:
                     return isIdentifierOrPattern();
                 case ParsingContext.ArrayBindingElements:
@@ -1641,21 +1661,44 @@ module ts {
             Debug.fail("Non-exhaustive case in 'isListElement'.");
         }
 
+        function isValidHeritageClauseObjectLiteral() {
+            Debug.assert(token === SyntaxKind.OpenBraceToken);
+            if (nextToken() === SyntaxKind.CloseBraceToken) {
+                // if we see  "extends {}" then only treat the {} as what we're extending (and not
+                // the class body) if we have:
+                //
+                //      extends {} { 
+                //      extends {},
+                //      extends {} extends
+                //      extends {} implements
+
+                let next = nextToken();
+                return next === SyntaxKind.CommaToken || next === SyntaxKind.OpenBraceToken || next === SyntaxKind.ExtendsKeyword || next === SyntaxKind.ImplementsKeyword;
+            }
+
+            return true;
+        }
+
         function nextTokenIsIdentifier() {
             nextToken();
             return isIdentifier();
         }
 
-        function isNotHeritageClauseTypeName(): boolean {
+        function isHeritageClauseExtendsOrImplementsKeyword(): boolean {
             if (token === SyntaxKind.ImplementsKeyword ||
                 token === SyntaxKind.ExtendsKeyword) {
 
-                return lookAhead(nextTokenIsIdentifier);
+                return lookAhead(nextTokenIsStartOfExpression);
             }
 
             return false;
         }
 
+        function nextTokenIsStartOfExpression() {
+            nextToken();
+            return isStartOfExpression();
+        }
+
         // True if positioned at a list terminator
         function isListTerminator(kind: ParsingContext): boolean {
             if (token === SyntaxKind.EndOfFileToken) {
@@ -1676,7 +1719,7 @@ module ts {
                     return token === SyntaxKind.CloseBraceToken;
                 case ParsingContext.SwitchClauseStatements:
                     return token === SyntaxKind.CloseBraceToken || token === SyntaxKind.CaseKeyword || token === SyntaxKind.DefaultKeyword;
-                case ParsingContext.TypeReferences:
+                case ParsingContext.HeritageClauseElement:
                     return token === SyntaxKind.OpenBraceToken || token === SyntaxKind.ExtendsKeyword || token === SyntaxKind.ImplementsKeyword;
                 case ParsingContext.VariableDeclarations:
                     return isVariableDeclaratorListTerminator();
@@ -1891,12 +1934,6 @@ module ts {
                 // This would probably be safe to reuse.  There is no speculative parsing with
                 // heritage clauses.
 
-                case ParsingContext.TypeReferences:
-                // This would probably be safe to reuse.  There is no speculative parsing with
-                // type names in a heritage clause.  There can be generic names in the type
-                // name list.  But because it is a type context, we never use speculative
-                // parsing on the type argument list.
-
                 case ParsingContext.TypeParameters:
                 // This would probably be safe to reuse.  There is no speculative parsing with
                 // type parameters.  Note that that's because type *parameters* only occur in
@@ -1923,6 +1960,12 @@ module ts {
                 // cases.  i.e. a property assignment may end with an expression, and thus might
                 // have lookahead far beyond it's old node.
                 case ParsingContext.ObjectLiteralMembers:
+
+                // This is probably not safe to reuse.  There can be speculative parsing with
+                // type names in a heritage clause.  There can be generic names in the type
+                // name list, and there can be left hand side expressions (which can have type
+                // arguments.)
+                case ParsingContext.HeritageClauseElement:
             }
 
             return false;
@@ -1957,6 +2000,7 @@ module ts {
                     case SyntaxKind.GetAccessor:
                     case SyntaxKind.SetAccessor:
                     case SyntaxKind.PropertyDeclaration:
+                    case SyntaxKind.SemicolonClassElement:
                         return true;
                 }
             }
@@ -2846,8 +2890,7 @@ module ts {
         }
 
         // EXPRESSIONS
-
-        function isStartOfExpression(): boolean {
+        function isStartOfLeftHandSideExpression(): boolean {
             switch (token) {
                 case SyntaxKind.ThisKeyword:
                 case SyntaxKind.SuperKeyword:
@@ -2862,9 +2905,23 @@ module ts {
                 case SyntaxKind.OpenBracketToken:
                 case SyntaxKind.OpenBraceToken:
                 case SyntaxKind.FunctionKeyword:
+                case SyntaxKind.ClassKeyword:
                 case SyntaxKind.NewKeyword:
                 case SyntaxKind.SlashToken:
                 case SyntaxKind.SlashEqualsToken:
+                case SyntaxKind.Identifier:
+                    return true;
+                default:
+                    return isIdentifier();
+            }
+        }
+
+        function isStartOfExpression(): boolean {
+            if (isStartOfLeftHandSideExpression()) {
+                return true;
+            }
+
+            switch (token) {
                 case SyntaxKind.PlusToken:
                 case SyntaxKind.MinusToken:
                 case SyntaxKind.TildeToken:
@@ -2875,7 +2932,6 @@ module ts {
                 case SyntaxKind.PlusPlusToken:
                 case SyntaxKind.MinusMinusToken:
                 case SyntaxKind.LessThanToken:
-                case SyntaxKind.Identifier:
                 case SyntaxKind.YieldKeyword:
                     // Yield always starts an expression.  Either it is an identifier (in which case
                     // it is definitely an expression).  Or it's a keyword (either because we're in
@@ -2895,8 +2951,12 @@ module ts {
         }
 
         function isStartOfExpressionStatement(): boolean {
-            // As per the grammar, neither '{' nor 'function' can start an expression statement.
-            return token !== SyntaxKind.OpenBraceToken && token !== SyntaxKind.FunctionKeyword && token !== SyntaxKind.AtToken && isStartOfExpression();
+            // As per the grammar, none of '{' or 'function' or 'class' can start an expression statement.
+            return token !== SyntaxKind.OpenBraceToken &&
+                token !== SyntaxKind.FunctionKeyword &&
+                token !== SyntaxKind.ClassKeyword &&
+                token !== SyntaxKind.AtToken &&
+                isStartOfExpression();
         }
 
         function parseExpression(): Expression {
@@ -3241,8 +3301,12 @@ module ts {
                 return parseFunctionBlock(/*allowYield:*/ false, /* ignoreMissingOpenBrace */ false);
             }
 
-            if (isStartOfStatement(/*inErrorRecovery:*/ true) && !isStartOfExpressionStatement() && token !== SyntaxKind.FunctionKeyword) {
-                // Check if we got a plain statement (i.e. no expression-statements, no functions expressions/declarations)
+            if (isStartOfStatement(/*inErrorRecovery:*/ true) &&
+                !isStartOfExpressionStatement() &&
+                token !== SyntaxKind.FunctionKeyword &&
+                token !== SyntaxKind.ClassKeyword) {
+
+                // Check if we got a plain statement (i.e. no expression-statements, no function/class expressions/declarations)
                 //
                 // Here we try to recover from a potential error situation in the case where the
                 // user meant to supply a block. For example, if the user wrote:
@@ -3667,7 +3731,6 @@ module ts {
                 case SyntaxKind.CloseBracketToken:              // foo<x>]
                 case SyntaxKind.ColonToken:                     // foo<x>:
                 case SyntaxKind.SemicolonToken:                 // foo<x>;
-                case SyntaxKind.CommaToken:                     // foo<x>,
                 case SyntaxKind.QuestionToken:                  // foo<x>?
                 case SyntaxKind.EqualsEqualsToken:              // foo<x> ==
                 case SyntaxKind.EqualsEqualsEqualsToken:        // foo<x> ===
@@ -3685,6 +3748,12 @@ module ts {
                     // treat it as such.
                     return true;
 
+                case SyntaxKind.CommaToken:                     // foo<x>,
+                case SyntaxKind.OpenBraceToken:                 // foo<x> {
+                    // We don't want to treat these as type arguments.  Otherwise we'll parse this
+                    // as an invocation expression.  Instead, we want to parse out the expression 
+                    // in isolation from the type arguments.
+
                 default:
                     // Anything else treat as an expression.
                     return false;
@@ -3709,6 +3778,8 @@ module ts {
                     return parseArrayLiteralExpression();
                 case SyntaxKind.OpenBraceToken:
                     return parseObjectLiteralExpression();
+                case SyntaxKind.ClassKeyword:
+                    return parseClassExpression();
                 case SyntaxKind.FunctionKeyword:
                     return parseFunctionExpression();
                 case SyntaxKind.NewKeyword:
@@ -4129,13 +4200,14 @@ module ts {
         }
 
         function isStartOfStatement(inErrorRecovery: boolean): boolean {
-            // Functions and variable statements are allowed as a statement.  But as per the grammar,
-            // they also allow modifiers.  So we have to check for those statements that might be
-            // following modifiers.This ensures that things work properly when incrementally parsing
-            // as the parser will produce the same FunctionDeclaraiton or VariableStatement if it has
-            // the same text regardless of whether it is inside a block or not.
+            // Functions, variable statements and classes are allowed as a statement.  But as per
+            // the grammar, they also allow modifiers.  So we have to check for those statements 
+            // that might be following modifiers.This ensures that things work properly when
+            // incrementally parsing as the parser will produce the same FunctionDeclaraiton, 
+            // VariableStatement or ClassDeclaration, if it has the same text regardless of whether 
+            // it is inside a block or not.
             if (isModifier(token)) {
-                let result = lookAhead(parseVariableStatementOrFunctionDeclarationWithDecoratorsOrModifiers);
+                let result = lookAhead(parseVariableStatementOrFunctionDeclarationOrClassDeclarationWithDecoratorsOrModifiers);
                 if (result) {
                     return true;
                 }
@@ -4154,6 +4226,7 @@ module ts {
                 case SyntaxKind.VarKeyword:
                 case SyntaxKind.LetKeyword:
                 case SyntaxKind.FunctionKeyword:
+                case SyntaxKind.ClassKeyword:
                 case SyntaxKind.IfKeyword:
                 case SyntaxKind.DoKeyword:
                 case SyntaxKind.WhileKeyword:
@@ -4178,7 +4251,6 @@ module ts {
                     let isConstEnum = lookAhead(nextTokenIsEnumKeyword);
                     return !isConstEnum;
                 case SyntaxKind.InterfaceKeyword:
-                case SyntaxKind.ClassKeyword:
                 case SyntaxKind.ModuleKeyword:
                 case SyntaxKind.EnumKeyword:
                 case SyntaxKind.TypeKeyword:
@@ -4222,6 +4294,8 @@ module ts {
                     return parseVariableStatement(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers:*/ undefined);
                 case SyntaxKind.FunctionKeyword:
                     return parseFunctionDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers:*/ undefined);
+                case SyntaxKind.ClassKeyword:
+                    return parseClassDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers:*/ undefined);
                 case SyntaxKind.SemicolonToken:
                     return parseEmptyStatement();
                 case SyntaxKind.IfKeyword:
@@ -4267,7 +4341,7 @@ module ts {
                     // Even though variable statements and function declarations cannot have decorators, 
                     // we parse them here to provide better error recovery.
                     if (isModifier(token) || token === SyntaxKind.AtToken) {
-                        let result = tryParse(parseVariableStatementOrFunctionDeclarationWithDecoratorsOrModifiers);
+                        let result = tryParse(parseVariableStatementOrFunctionDeclarationOrClassDeclarationWithDecoratorsOrModifiers);
                         if (result) {
                             return result;
                         }
@@ -4277,7 +4351,7 @@ module ts {
             }
         }
 
-        function parseVariableStatementOrFunctionDeclarationWithDecoratorsOrModifiers(): FunctionDeclaration | VariableStatement {
+        function parseVariableStatementOrFunctionDeclarationOrClassDeclarationWithDecoratorsOrModifiers(): FunctionDeclaration | VariableStatement | ClassDeclaration {
             let start = scanner.getStartPos();
             let decorators = parseDecorators();
             let modifiers = parseModifiers();
@@ -4297,8 +4371,12 @@ module ts {
 
                 case SyntaxKind.VarKeyword:
                     return parseVariableStatement(start, decorators, modifiers);
+
                 case SyntaxKind.FunctionKeyword:
                     return parseFunctionDeclaration(start, decorators, modifiers);
+
+                case SyntaxKind.ClassKeyword:
+                    return parseClassDeclaration(start, decorators, modifiers);
             }
 
             return undefined;
@@ -4619,6 +4697,12 @@ module ts {
         }
 
         function parseClassElement(): ClassElement {
+            if (token === SyntaxKind.SemicolonToken) {
+                let result = <SemicolonClassElement>createNode(SyntaxKind.SemicolonClassElement);
+                nextToken();
+                return finishNode(result);
+            }
+
             let fullStart = getNodePos();
             let decorators = parseDecorators();
             let modifiers = parseModifiers();
@@ -4657,14 +4741,26 @@ module ts {
             Debug.fail("Should not have attempted to parse class member declaration.");
         }
 
+        function parseClassExpression(): ClassExpression {
+            return <ClassExpression>parseClassDeclarationOrExpression(
+                /*fullStart:*/ scanner.getStartPos(),
+                /*decorators:*/ undefined,
+                /*modifiers:*/ undefined,
+                SyntaxKind.ClassExpression);
+        }
+
         function parseClassDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): ClassDeclaration {
+            return <ClassDeclaration>parseClassDeclarationOrExpression(fullStart, decorators, modifiers, SyntaxKind.ClassDeclaration);
+        }
+
+        function parseClassDeclarationOrExpression(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray, kind: SyntaxKind): ClassLikeDeclaration {
             // In ES6 specification, All parts of a ClassDeclaration or a ClassExpression are strict mode code
             let savedStrictModeContext = inStrictModeContext();
             if (languageVersion >= ScriptTarget.ES6) {
                 setStrictModeContext(true);
             }
 
-            var node = <ClassDeclaration>createNode(SyntaxKind.ClassDeclaration, fullStart);
+            var node = <ClassLikeDeclaration>createNode(kind, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
             parseExpected(SyntaxKind.ClassKeyword);
@@ -4714,13 +4810,23 @@ module ts {
                 let node = <HeritageClause>createNode(SyntaxKind.HeritageClause);
                 node.token = token;
                 nextToken();
-                node.types = parseDelimitedList(ParsingContext.TypeReferences, parseTypeReference);
+                node.types = parseDelimitedList(ParsingContext.HeritageClauseElement, parseHeritageClauseElement);
                 return finishNode(node);
             }
 
             return undefined;
         }
 
+        function parseHeritageClauseElement(): HeritageClauseElement {
+            let node = <HeritageClauseElement>createNode(SyntaxKind.HeritageClauseElement);
+            node.expression = parseLeftHandSideExpressionOrHigher();
+            if (token === SyntaxKind.LessThanToken) {
+                node.typeArguments = parseBracketedList(ParsingContext.TypeArguments, parseType, SyntaxKind.LessThanToken, SyntaxKind.GreaterThanToken);
+            }
+
+            return finishNode(node);
+        }
+
         function isHeritageClause(): boolean {
             return token === SyntaxKind.ExtendsKeyword || token === SyntaxKind.ImplementsKeyword;
         }
@@ -5263,6 +5369,7 @@ module ts {
                 case SyntaxKind.ArrayLiteralExpression:
                 case SyntaxKind.ParenthesizedExpression:
                 case SyntaxKind.ObjectLiteralExpression:
+                case SyntaxKind.ClassExpression:
                 case SyntaxKind.FunctionExpression:
                 case SyntaxKind.Identifier:
                 case SyntaxKind.RegularExpressionLiteral:

src/compiler/program.ts

@@ -8,7 +8,7 @@ module ts {
     /* @internal */ export let ioWriteTime = 0;
 
     /** The version of the TypeScript compiler release */
-    export let version = "1.5.0.0";
+    export let version = "1.5.0";
 
     export function findConfigFile(searchPath: string): string {
         var fileName = "tsconfig.json";
@@ -454,6 +454,24 @@ module ts {
         }
 
         function verifyCompilerOptions() {
+            if (options.separateCompilation) {
+                if (options.sourceMap) {
+                    diagnostics.add(createCompilerDiagnostic(Diagnostics.Option_sourceMap_cannot_be_specified_with_option_separateCompilation));
+                }
+
+                if (options.declaration) {
+                    diagnostics.add(createCompilerDiagnostic(Diagnostics.Option_declaration_cannot_be_specified_with_option_separateCompilation));
+                }
+
+                if (options.noEmitOnError) {
+                    diagnostics.add(createCompilerDiagnostic(Diagnostics.Option_noEmitOnError_cannot_be_specified_with_option_separateCompilation));
+                }
+
+                if (options.out) {
+                    diagnostics.add(createCompilerDiagnostic(Diagnostics.Option_out_cannot_be_specified_with_option_separateCompilation));
+                }
+            }
+
             if (!options.sourceMap && (options.mapRoot || options.sourceRoot)) {
                 // Error to specify --mapRoot or --sourceRoot without mapSourceFiles
                 if (options.mapRoot) {
@@ -468,12 +486,21 @@ module ts {
             let languageVersion = options.target || ScriptTarget.ES3;
 
             let firstExternalModuleSourceFile = forEach(files, f => isExternalModule(f) ? f : undefined);
-            if (firstExternalModuleSourceFile && !options.module) {
+            if (options.separateCompilation) {
                 if (!options.module && languageVersion < ScriptTarget.ES6) {
-                    // We cannot use createDiagnosticFromNode because nodes do not have parents yet 
-                    let span = getErrorSpanForNode(firstExternalModuleSourceFile, firstExternalModuleSourceFile.externalModuleIndicator);
-                    diagnostics.add(createFileDiagnostic(firstExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_external_modules_unless_the_module_flag_is_provided));
+                    diagnostics.add(createCompilerDiagnostic(Diagnostics.Option_separateCompilation_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES6_or_higher));
                 }
+
+                let firstNonExternalModuleSourceFile = forEach(files, f => !isExternalModule(f) && !isDeclarationFile(f) ? f : undefined);
+                if (firstNonExternalModuleSourceFile) {
+                    let span = getErrorSpanForNode(firstNonExternalModuleSourceFile, firstNonExternalModuleSourceFile);
+                    diagnostics.add(createFileDiagnostic(firstNonExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_non_external_modules_when_the_separateCompilation_flag_is_provided));
+                }
+            }
+            else if (firstExternalModuleSourceFile && languageVersion < ScriptTarget.ES6 && !options.module) {
+                // We cannot use createDiagnosticFromNode because nodes do not have parents yet 
+                let span = getErrorSpanForNode(firstExternalModuleSourceFile, firstExternalModuleSourceFile.externalModuleIndicator);
+                diagnostics.add(createFileDiagnostic(firstExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_external_modules_unless_the_module_flag_is_provided));
             }
 
             // Cannot specify module gen target when in es6 or above
@@ -481,11 +508,11 @@ module ts {
                 diagnostics.add(createCompilerDiagnostic(Diagnostics.Cannot_compile_external_modules_into_amd_or_commonjs_when_targeting_es6_or_higher));
             }
 
-            // there has to be common source directory if user specified --outdir || --sourcRoot
+            // there has to be common source directory if user specified --outdir || --sourceRoot
             // if user specified --mapRoot, there needs to be common source directory if there would be multiple files being emitted
             if (options.outDir || // there is --outDir specified
                 options.sourceRoot || // there is --sourceRoot specified
-                (options.mapRoot &&  // there is --mapRoot Specified and there would be multiple js files generated
+                (options.mapRoot &&  // there is --mapRoot specified and there would be multiple js files generated
                     (!options.out || firstExternalModuleSourceFile !== undefined))) {
 
                 let commonPathComponents: string[];

src/compiler/tsc.ts

@@ -276,6 +276,7 @@ module ts {
 
         // If a source file changes, mark it as unwatched and start the recompilation timer
         function sourceFileChanged(sourceFile: SourceFile) {
+            sourceFile.fileWatcher.close();
             sourceFile.fileWatcher = undefined;
             startTimer();
         }

src/compiler/types.ts

@@ -203,9 +203,12 @@ module ts {
         TemplateExpression,
         YieldExpression,
         SpreadElementExpression,
+        ClassExpression,
         OmittedExpression,
         // Misc
         TemplateSpan,
+        HeritageClauseElement,
+        SemicolonClassElement,
         // Element
         Block,
         VariableStatement,
@@ -536,6 +539,11 @@ module ts {
         body?: Block;
     }
 
+    // For when we encounter a semicolon in a class declaration.  ES6 allows these as class elements.
+    export interface SemicolonClassElement extends ClassElement {
+        _semicolonClassElementBrand: any;
+    }
+
     // See the comment on MethodDeclaration for the intuition behind AccessorDeclaration being a
     // ClassElement and an ObjectLiteralElement.
     export interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
@@ -728,6 +736,11 @@ module ts {
         arguments: NodeArray<Expression>;
     }
 
+    export interface HeritageClauseElement extends Node {
+        expression: LeftHandSideExpression;
+        typeArguments?: NodeArray<TypeNode>;
+    }
+
     export interface NewExpression extends CallExpression, PrimaryExpression { }
 
     export interface TaggedTemplateExpression extends MemberExpression {
@@ -849,13 +862,19 @@ module ts {
         _moduleElementBrand: any;
     }
 
-    export interface ClassDeclaration extends Declaration, ModuleElement {
+    export interface ClassLikeDeclaration extends Declaration {
         name?: Identifier;
         typeParameters?: NodeArray<TypeParameterDeclaration>;
         heritageClauses?: NodeArray<HeritageClause>;
         members: NodeArray<ClassElement>;
     }
 
+    export interface ClassDeclaration extends ClassLikeDeclaration, Statement {
+    }
+
+    export interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
+    }
+
     export interface ClassElement extends Declaration {
         _classElementBrand: any;
     }
@@ -869,7 +888,7 @@ module ts {
 
     export interface HeritageClause extends Node {
         token: SyntaxKind;
-        types?: NodeArray<TypeReferenceNode>;
+        types?: NodeArray<HeritageClauseElement>;
     }
 
     export interface TypeAliasDeclaration extends Declaration, ModuleElement {
@@ -1231,7 +1250,7 @@ module ts {
         writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
-        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
+        isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
         // Returns the constant value this property access resolves to, or 'undefined' for a non-constant
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
         resolvesToSomeValue(location: Node, name: string): boolean;
@@ -1560,7 +1579,6 @@ module ts {
     export interface CompilerOptions {
         allowNonTsExtensions?: boolean;
         charset?: string;
-        codepage?: number;
         declaration?: boolean;
         diagnostics?: boolean;
         emitBOM?: boolean;
@@ -1574,7 +1592,6 @@ module ts {
         noErrorTruncation?: boolean;
         noImplicitAny?: boolean;
         noLib?: boolean;
-        noLibCheck?: boolean;
         noResolve?: boolean;
         out?: string;
         outDir?: string;
@@ -1587,9 +1604,8 @@ module ts {
         target?: ScriptTarget;
         version?: boolean;
         watch?: boolean;
+        separateCompilation?: boolean;
         /* @internal */ stripInternal?: boolean;
-        /* @internal */ preserveNewLines?: boolean;
-        /* @internal */ cacheDownlevelForOfLength?: boolean;
         [option: string]: string | number | boolean;
     }
 

src/compiler/utilities.ts

@@ -145,7 +145,7 @@ module ts {
 
         return node.pos === node.end && node.kind !== SyntaxKind.EndOfFileToken;
     }
-    
+
     export function nodeIsPresent(node: Node) {
         return !nodeIsMissing(node);
     }
@@ -274,11 +274,19 @@ module ts {
     export function getErrorSpanForNode(sourceFile: SourceFile, node: Node): TextSpan {
         let errorNode = node;
         switch (node.kind) {
+            case SyntaxKind.SourceFile:
+                let pos = skipTrivia(sourceFile.text, 0, /*stopAfterLineBreak*/ false);
+                if (pos === sourceFile.text.length) {
+                    // file is empty - return span for the beginning of the file
+                    return createTextSpan(0, 0);
+                }
+                return getSpanOfTokenAtPosition(sourceFile, pos);
             // This list is a work in progress. Add missing node kinds to improve their error
             // spans.
             case SyntaxKind.VariableDeclaration:
             case SyntaxKind.BindingElement:
             case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.InterfaceDeclaration:
             case SyntaxKind.ModuleDeclaration:
             case SyntaxKind.EnumDeclaration:
@@ -288,7 +296,7 @@ module ts {
                 errorNode = (<Declaration>node).name;
                 break;
         }
-        
+
         if (errorNode === undefined) {
             // If we don't have a better node, then just set the error on the first token of 
             // construct.
@@ -634,7 +642,7 @@ module ts {
 
         return false;
     }
-    
+
     export function childIsDecorated(node: Node): boolean {
         switch (node.kind) {
             case SyntaxKind.ClassDeclaration:
@@ -670,6 +678,7 @@ module ts {
             case SyntaxKind.TypeAssertionExpression:
             case SyntaxKind.ParenthesizedExpression:
             case SyntaxKind.FunctionExpression:
+            case SyntaxKind.ClassExpression:
             case SyntaxKind.ArrowFunction:
             case SyntaxKind.VoidExpression:
             case SyntaxKind.DeleteExpression:
@@ -745,7 +754,7 @@ module ts {
     export function isInstantiatedModule(node: ModuleDeclaration, preserveConstEnums: boolean) {
         let moduleState = getModuleInstanceState(node)
         return moduleState === ModuleInstanceState.Instantiated ||
-               (preserveConstEnums && moduleState === ModuleInstanceState.ConstEnumOnly);
+            (preserveConstEnums && moduleState === ModuleInstanceState.ConstEnumOnly);
     }
 
     export function isExternalModuleImportEqualsDeclaration(node: Node) {
@@ -942,12 +951,12 @@ module ts {
             node.kind === SyntaxKind.ExportAssignment && (<ExportAssignment>node).expression.kind === SyntaxKind.Identifier;
     }
 
-    export function getClassBaseTypeNode(node: ClassDeclaration) {
+    export function getClassExtendsHeritageClauseElement(node: ClassLikeDeclaration) {
         let heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword);
         return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined;
     }
 
-    export function getClassImplementedTypeNodes(node: ClassDeclaration) {
+    export function getClassImplementsHeritageClauseElements(node: ClassDeclaration) {
         let heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ImplementsKeyword);
         return heritageClause ? heritageClause.types : undefined;
     }
@@ -1161,7 +1170,7 @@ module ts {
     export function createTextSpanFromBounds(start: number, end: number) {
         return createTextSpan(start, end - start);
     }
-    
+
     export function textChangeRangeNewSpan(range: TextChangeRange) {
         return createTextSpan(range.span.start, range.newLength);
     }
@@ -1435,13 +1444,13 @@ module ts {
             return escapedCharsMap[c] || get16BitUnicodeEscapeSequence(c.charCodeAt(0));
         }
     }
-    
+
     function get16BitUnicodeEscapeSequence(charCode: number): string {
         let hexCharCode = charCode.toString(16).toUpperCase();
         let paddedHexCode = ("0000" + hexCharCode).slice(-4);
         return "\\u" + paddedHexCode;
     }
-    
+
     let nonAsciiCharacters = /[^\u0000-\u007F]/g;
     export function escapeNonAsciiCharacters(s: string): string {
         // Replace non-ASCII characters with '\uNNNN' escapes if any exist.
@@ -1573,7 +1582,7 @@ module ts {
         return getLineAndCharacterOfPosition(currentSourceFile, pos).line;
     }
 
-    export function getFirstConstructorWithBody(node: ClassDeclaration): ConstructorDeclaration {
+    export function getFirstConstructorWithBody(node: ClassLikeDeclaration): ConstructorDeclaration {
         return forEach(node.members, member => {
             if (member.kind === SyntaxKind.Constructor && nodeIsPresent((<ConstructorDeclaration>member).body)) {
                 return <ConstructorDeclaration>member;
@@ -1768,4 +1777,30 @@ module ts {
         }
     }
 
+    // Returns false if this heritage clause element's expression contains something unsupported
+    // (i.e. not a name or dotted name).
+    export function isSupportedHeritageClauseElement(node: HeritageClauseElement): boolean {
+        return isSupportedHeritageClauseElementExpression(node.expression);
+    }
+
+    function isSupportedHeritageClauseElementExpression(node: Expression): boolean {
+        if (node.kind === SyntaxKind.Identifier) {
+            return true;
+        }
+        else if (node.kind === SyntaxKind.PropertyAccessExpression) {
+            return isSupportedHeritageClauseElementExpression((<PropertyAccessExpression>node).expression);
+        }
+        else {
+            return false;
+        }
+    }
+
+    export function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) {
+        return (node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node) ||
+            (node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node);
+    }
+
+    export function getLocalSymbolForExportDefault(symbol: Symbol) {
+            return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & NodeFlags.Default) ? symbol.valueDeclaration.localSymbol : undefined;
+    }
 }

src/harness/harness.ts

@@ -1008,10 +1008,6 @@ module Harness {
                             options.outDir = setting.value;
                             break;
 
-                        case 'preservenewlines':
-                            options.preserveNewLines = !!setting.value;
-                            break;
-
                         case 'sourceroot':
                             options.sourceRoot = setting.value;
                             break;
@@ -1040,17 +1036,7 @@ module Harness {
                             useCaseSensitiveFileNames = setting.value === 'true';
                             break;
 
-                        case 'mapsourcefiles':
-                        case 'maproot':
-                        case 'generatedeclarationfiles':
-                        case 'gatherDiagnostics':
-                        case 'codepage':
-                        case 'createFileLog':
                         case 'filename':
-                        case 'removecomments':
-                        case 'watch':
-                        case 'allowautomaticsemicoloninsertion':
-                        case 'locale':
                             // Not supported yet
                             break;
 
@@ -1066,6 +1052,10 @@ module Harness {
                             options.preserveConstEnums = setting.value === 'true';
                             break;
 
+                        case 'separatecompilation':
+                            options.separateCompilation = setting.value === 'true';
+                            break;
+
                         case 'suppressimplicitanyindexerrors':
                             options.suppressImplicitAnyIndexErrors = setting.value === 'true';
                             break;
@@ -1465,7 +1455,12 @@ module Harness {
         var optionRegex = /^[\/]{2}\s*@(\w+)\s*:\s*(\S*)/gm;  // multiple matches on multiple lines
 
         // List of allowed metadata names
-        var fileMetadataNames = ["filename", "comments", "declaration", "module", "nolib", "sourcemap", "target", "out", "outdir", "noemitonerror", "noimplicitany", "noresolve", "newline", "newlines", "emitbom", "errortruncation", "usecasesensitivefilenames", "preserveconstenums", "preservenewlines", "includebuiltfile", "suppressimplicitanyindexerrors", "stripinternal"];
+        var fileMetadataNames = ["filename", "comments", "declaration", "module",
+            "nolib", "sourcemap", "target", "out", "outdir", "noemitonerror",
+            "noimplicitany", "noresolve", "newline", "newlines", "emitbom",
+            "errortruncation", "usecasesensitivefilenames", "preserveconstenums",
+            "includebuiltfile", "suppressimplicitanyindexerrors", "stripinternal",
+            "separatecompilation"];
 
         function extractCompilerSettings(content: string): CompilerSetting[] {
 
@@ -1703,6 +1698,14 @@ module Harness {
         return (Path.getFileName(filePath) === 'lib.d.ts') || (Path.getFileName(filePath) === 'lib.core.d.ts');
     }
 
+    export function getDefaultLibraryFile(): { unitName: string, content: string } {
+        var libFile = Harness.userSpecifiedroot + Harness.libFolder + "/" + "lib.d.ts";
+        return {
+            unitName: libFile,
+            content: IO.readFile(libFile)
+        }
+    }
+
     if (Error) (<any>Error).stackTraceLimit = 1;
 }
 

src/harness/loggedIO.ts

@@ -15,6 +15,7 @@ interface IOLog {
     arguments: string[];
     executingPath: string;
     currentDirectory: string;
+    useCustomLibraryFile?: boolean;
     filesRead: {
         path: string;
         codepage: number;

src/harness/rwcRunner.ts

@@ -32,6 +32,7 @@ module RWC {
             };
             var baseName = /(.*)\/(.*).json/.exec(ts.normalizeSlashes(jsonPath))[2];
             var currentDirectory: string;
+            var useCustomLibraryFile: boolean;
 
             after(() => {
                 // Mocha holds onto the closure environment of the describe callback even after the test is done.
@@ -43,6 +44,10 @@ module RWC {
                 baselineOpts = undefined;
                 baseName = undefined;
                 currentDirectory = undefined;
+                // useCustomLibraryFile is a flag specified in the json object to indicate whether to use built/local/lib.d.ts
+                // or to use lib.d.ts inside the json object. If the flag is true, use the lib.d.ts inside json file
+                // otherwise use the lib.d.ts from built/local
+                useCustomLibraryFile = undefined;
             });
 
             it('can compile', () => {
@@ -51,34 +56,52 @@ module RWC {
 
                 var ioLog: IOLog = JSON.parse(Harness.IO.readFile(jsonPath));
                 currentDirectory = ioLog.currentDirectory;
+                useCustomLibraryFile = ioLog.useCustomLibraryFile;
                 runWithIOLog(ioLog, () => {
                     opts = ts.parseCommandLine(ioLog.arguments);
                     assert.equal(opts.errors.length, 0);
+
+                    // To provide test coverage of output javascript file,
+                    // we will set noEmitOnError flag to be false.
+                    opts.options.noEmitOnError = false;
                 });
 
                 runWithIOLog(ioLog, () => {
                     harnessCompiler.reset();
+
                     // Load the files
                     ts.forEach(opts.fileNames, fileName => {
                         inputFiles.push(getHarnessCompilerInputUnit(fileName));
                     });
 
-                    if (!opts.options.noLib) {
-                        // Find the lib.d.ts file in the input file and add it to the input files list
-                        var libFile = ts.forEach(ioLog.filesRead, fileRead=> Harness.isLibraryFile(fileRead.path) ? fileRead.path : undefined);
-                        if (libFile) {
-                            inputFiles.push(getHarnessCompilerInputUnit(libFile));
-                        }
-                    }
-
-                    ts.forEach(ioLog.filesRead, fileRead => {
+                    // Add files to compilation
+                    for(let fileRead of ioLog.filesRead) {
+                        // Check if the file is already added into the set of input files.
                         var resolvedPath = ts.normalizeSlashes(ts.sys.resolvePath(fileRead.path));
-                        var inInputList = ts.forEach(inputFiles, inputFile=> inputFile.unitName === resolvedPath);
-                        if (!inInputList) {
-                            // Add the file to other files
+                        var inInputList = ts.forEach(inputFiles, inputFile => inputFile.unitName === resolvedPath);
+
+                        if (!Harness.isLibraryFile(fileRead.path)) {
+                            if (inInputList) {
+                                continue;
+                            }
                             otherFiles.push(getHarnessCompilerInputUnit(fileRead.path));
                         }
-                    });
+                        else if (!opts.options.noLib && Harness.isLibraryFile(fileRead.path)){
+                            if (!inInputList) {
+                                // If useCustomLibraryFile is true, we will use lib.d.ts from json object
+                                // otherwise use the lib.d.ts from built/local
+                                // Majority of RWC code will be using built/local/lib.d.ts instead of
+                                // lib.d.ts inside json file. However, some RWC cases will still use
+                                // their own version of lib.d.ts because they have customized lib.d.ts
+                                if (useCustomLibraryFile) {
+                                    inputFiles.push(getHarnessCompilerInputUnit(fileRead.path));
+                                }
+                                else {
+                                    inputFiles.push(Harness.getDefaultLibraryFile());
+                                }
+                            }
+                        }
+                    }
 
                     // do not use lib since we already read it in above
                     opts.options.noLib = true;
@@ -115,9 +138,10 @@ module RWC {
 
             it('has the expected declaration file content', () => {
                 Harness.Baseline.runBaseline('has the expected declaration file content', baseName + '.d.ts', () => {
-                    if (compilerResult.errors.length || !compilerResult.declFilesCode.length) {
+                    if (!compilerResult.declFilesCode.length) {
                         return null;
                     }
+
                     return Harness.Compiler.collateOutputs(compilerResult.declFilesCode);
                 }, false, baselineOpts);
             });

src/harness/typeWriter.ts

@@ -38,7 +38,6 @@ class TypeWriterWalker {
             case ts.SyntaxKind.SuperKeyword:
             case ts.SyntaxKind.ArrayLiteralExpression:
             case ts.SyntaxKind.ObjectLiteralExpression:
-            case ts.SyntaxKind.PropertyAccessExpression:
             case ts.SyntaxKind.ElementAccessExpression:
             case ts.SyntaxKind.CallExpression:
             case ts.SyntaxKind.NewExpression:
@@ -56,6 +55,14 @@ class TypeWriterWalker {
                 this.log(node, this.getTypeOfNode(node));
                 break;
 
+            case ts.SyntaxKind.PropertyAccessExpression:
+                for (var current = node; current.kind === ts.SyntaxKind.PropertyAccessExpression; current = current.parent) {
+                }
+                if (current.kind !== ts.SyntaxKind.HeritageClauseElement) {
+                    this.log(node, this.getTypeOfNode(node));
+                }
+                break;
+
             // Should not change expression status (maybe expressions)
             // TODO: Again, ideally should log number and string literals too,
             // but to be consistent with the old typeWriter, just log identifiers

src/lib/scriptHost.d.ts

@@ -4,7 +4,11 @@
 /// Windows Script Host APIS
 /////////////////////////////
 
-declare var ActiveXObject: { new (s: string): any; };
+
+interface ActiveXObject {
+    new (s: string): any;
+}
+declare var ActiveXObject: ActiveXObject;
 
 interface ITextWriter {
     Write(s: string): void;
@@ -12,11 +16,157 @@ interface ITextWriter {
     Close(): void;
 }
 
-declare var WScript: {
-    Echo(s: any): void;
-    StdErr: ITextWriter;
-    StdOut: ITextWriter;
-    Arguments: { length: number; Item(n: number): string; };
-    ScriptFullName: string;
-    Quit(exitCode?: number): number;
+interface TextStreamBase {
+    /**
+     * The column number of the current character position in an input stream.
+     */
+    Column: number;
+    /**
+     * The current line number in an input stream.
+     */
+    Line: number;
+    /**
+     * Closes a text stream.
+     * It is not necessary to close standard streams; they close automatically when the process ends. If you close a standard stream, be aware that any other pointers to that standard stream become invalid.
+     */
+    Close(): void;
 }
+
+interface TextStreamWriter extends TextStreamBase {
+    /**
+     * Sends a string to an output stream.
+     */
+    Write(s: string): void;
+    /**
+     * Sends a specified number of blank lines (newline characters) to an output stream.
+     */
+    WriteBlankLines(intLines: number): void;
+    /**
+     * Sends a string followed by a newline character to an output stream.
+     */
+    WriteLine(s: string): void;
+}
+
+interface TextStreamReader extends TextStreamBase {
+    /**
+     * Returns a specified number of characters from an input stream, beginning at the current pointer position.
+     * Does not return until the ENTER key is pressed.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    Read(characters: number): string;
+    /**
+     * Returns all characters from an input stream.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    ReadAll(): string;
+    /**
+     * Returns an entire line from an input stream.
+     * Although this method extracts the newline character, it does not add it to the returned string.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     */
+    ReadLine(): string;
+    /**
+     * Skips a specified number of characters when reading from an input text stream.
+     * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
+     * @param characters Positive number of characters to skip forward. (Backward skipping is not supported.)
+     */
+    Skip(characters: number): void;
+    /**
+     * Skips the next line when reading from an input text stream.
+     * Can only be used on a stream in reading mode, not writing or appending mode.
+     */
+    SkipLine(): void;
+    /**
+     * Indicates whether the stream pointer position is at the end of a line.
+     */
+    AtEndOfLine: boolean;
+    /**
+     * Indicates whether the stream pointer position is at the end of a stream.
+     */
+    AtEndOfStream: boolean;
+}
+
+declare var WScript: {
+    /**
+    * Outputs text to either a message box (under WScript.exe) or the command console window followed by a newline (under CScript.ext).
+    */
+    Echo(s: any): void;
+    /**
+     * Exposes the write-only error output stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdErr: TextStreamWriter;
+    /**
+     * Exposes the write-only output stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdOut: TextStreamWriter;
+    Arguments: { length: number; Item(n: number): string; };
+    /**
+     *  The full path of the currently running script.
+     */
+    ScriptFullName: string;
+    /**
+     * Forces the script to stop immediately, with an optional exit code.
+     */
+    Quit(exitCode?: number): number;
+    /**
+     * The Windows Script Host build version number.
+     */
+    BuildVersion: number;
+    /**
+     * Fully qualified path of the host executable.
+     */
+    FullName: string;
+    /**
+     * Gets/sets the script mode - interactive(true) or batch(false).
+     */
+    Interactive: boolean;
+    /**
+     * The name of the host executable (WScript.exe or CScript.exe).
+     */
+    Name: string;
+    /**
+     * Path of the directory containing the host executable.
+     */
+    Path: string;
+    /**
+     * The filename of the currently running script.
+     */
+    ScriptName: string;
+    /**
+     * Exposes the read-only input stream for the current script.
+     * Can be accessed only while using CScript.exe.
+     */
+    StdIn: TextStreamReader;
+    /**
+     * Windows Script Host version
+     */
+    Version: string;
+    /**
+     * Connects a COM object's event sources to functions named with a given prefix, in the form prefix_event.
+     */
+    ConnectObject(objEventSource: any, strPrefix: string): void;
+    /**
+     * Creates a COM object.
+     * @param strProgiID
+     * @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
+     */
+    CreateObject(strProgID: string, strPrefix?: string): any;
+    /**
+     * Disconnects a COM object from its event sources.
+     */
+    DisconnectObject(obj: any): void;
+    /**
+     * Retrieves an existing object with the specified ProgID from memory, or creates a new one from a file.
+     * @param strPathname Fully qualified path to the file containing the object persisted to disk. For objects in memory, pass a zero-length string.
+     * @param strProgID
+     * @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
+     */
+    GetObject(strPathname: string, strProgID?: string, strPrefix?: string): any;
+    /**
+     * Suspends script execution for a specified length of time, then continues execution.
+     * @param intTime Interval (in milliseconds) to suspend script execution.
+     */
+    Sleep(intTime: number): void;
+};

src/server/editorServices.ts

@@ -764,6 +764,26 @@ module ts.server {
             return info;
         }
 
+        // This is different from the method the compiler uses because
+        // the compiler can assume it will always start searching in the
+        // current directory (the directory in which tsc was invoked).
+        // The server must start searching from the directory containing
+        // the newly opened file.
+        findConfigFile(searchPath: string): string {
+            while (true) {
+                var fileName = ts.combinePaths(searchPath, "tsconfig.json");
+                if (sys.fileExists(fileName)) {
+                    return fileName;
+                }
+                var parentPath = ts.getDirectoryPath(searchPath);
+                if (parentPath === searchPath) {
+                    break;
+                }
+                searchPath = parentPath;
+            }
+            return undefined;
+        }
+
         /**
          * Open file whose contents is managed by the client
          * @param filename is absolute pathname
@@ -771,7 +791,13 @@ module ts.server {
 
         openClientFile(fileName: string) {
             var searchPath = ts.normalizePath(getDirectoryPath(fileName));
-            var configFileName = ts.findConfigFile(searchPath);
+            this.log("Search path: " + searchPath,"Info");
+            var configFileName = this.findConfigFile(searchPath);
+            if (configFileName) {
+                this.log("Config file name: " + configFileName, "Info");
+            } else {
+                this.log("no config file");
+            }
             if (configFileName) {
                 configFileName = getAbsolutePath(configFileName, searchPath);
             }

src/services/services.ts

@@ -1635,6 +1635,61 @@ module ts {
         sourceFile.scriptSnapshot = scriptSnapshot;
     }
 
+    /*
+     * This function will compile source text from 'input' argument using specified compiler options.
+     * If not options are provided - it will use a set of default compiler options.
+     * Extra compiler options that will unconditionally be used bu this function are:
+     * - separateCompilation = true
+     * - allowNonTsExtensions = true
+     */
+    export function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string {
+        let options = compilerOptions ? clone(compilerOptions) : getDefaultCompilerOptions();
+
+        options.separateCompilation = true;
+
+        // Filename can be non-ts file.
+        options.allowNonTsExtensions = true;
+
+        // Parse
+        var inputFileName = fileName || "module.ts";
+        var sourceFile = createSourceFile(inputFileName, input, options.target);
+
+        // Store syntactic diagnostics
+        if (diagnostics && sourceFile.parseDiagnostics) {
+            diagnostics.push(...sourceFile.parseDiagnostics);
+        }
+
+        // Output
+        let outputText: string;
+
+        // Create a compilerHost object to allow the compiler to read and write files
+        var compilerHost: CompilerHost = {
+            getSourceFile: (fileName, target) => fileName === inputFileName ? sourceFile : undefined,
+            writeFile: (name, text, writeByteOrderMark) => {
+                Debug.assert(outputText === undefined, "Unexpected multiple outputs for the file: " + name);
+                outputText = text;
+            },
+            getDefaultLibFileName: () => "lib.d.ts",
+            useCaseSensitiveFileNames: () => false,
+            getCanonicalFileName: fileName => fileName,
+            getCurrentDirectory: () => "",
+            getNewLine: () => "\r\n"
+        };
+
+        var program = createProgram([inputFileName], options, compilerHost);
+
+        if (diagnostics) {
+            diagnostics.push(...program.getGlobalDiagnostics());
+        }
+
+        // Emit
+        program.emit();
+
+        Debug.assert(outputText !== undefined, "Output generation failed");
+
+        return outputText;
+    }
+
     export function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile {
         let sourceFile = createSourceFile(fileName, scriptSnapshot.getText(0, scriptSnapshot.getLength()), scriptTarget, setNodeParents);
         setSourceFileFields(sourceFile, scriptSnapshot, version);
@@ -2404,6 +2459,14 @@ module ts {
                 return undefined;
             }
 
+            // If this is the default export, get the name of the declaration if it exists
+            if (displayName === "default") {
+                let localSymbol = getLocalSymbolForExportDefault(symbol);
+                if (localSymbol && localSymbol.name) {
+                    displayName = symbol.valueDeclaration.localSymbol.name;
+                }
+            }
+
             let firstCharCode = displayName.charCodeAt(0);
             // First check of the displayName is not external module; if it is an external module, it is not valid entry
             if ((symbol.flags & SymbolFlags.Namespace) && (firstCharCode === CharacterCodes.singleQuote || firstCharCode === CharacterCodes.doubleQuote)) {
@@ -2630,7 +2693,7 @@ module ts {
                         previousToken.getStart() :
                         position;
 
-                    let scopeNode = getScopeNode(contextToken, adjustedPosition, sourceFile);
+                    let scopeNode = getScopeNode(contextToken, adjustedPosition, sourceFile) || sourceFile;
 
                     /// TODO filter meaning based on the current context
                     let symbolMeanings = SymbolFlags.Type | SymbolFlags.Value | SymbolFlags.Namespace | SymbolFlags.Alias;
@@ -2942,7 +3005,7 @@ module ts {
 
         function getCompletionsAtPosition(fileName: string, position: number): CompletionInfo {
             synchronizeHostData();
-            
+
             let completionData = getCompletionData(fileName, position);
             if (!completionData) {
                 return undefined;
@@ -3651,8 +3714,24 @@ module ts {
             }
         }
 
-        /// References and Occurrences
         function getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[] {
+            let results = getOccurrencesAtPositionCore(fileName, position);
+            
+            if (results) {
+                let sourceFile = getCanonicalFileName(normalizeSlashes(fileName));
+
+                // ensure the results are in the file we're interested in
+                results.forEach((value) => {
+                    let targetFile = getCanonicalFileName(normalizeSlashes(value.fileName));
+                    Debug.assert(sourceFile == targetFile, `Unexpected file in results. Found results in ${targetFile} expected only results in ${sourceFile}.`);
+                });
+            }
+
+            return results;
+        }
+
+        /// References and Occurrences
+        function getOccurrencesAtPositionCore(fileName: string, position: number): ReferenceEntry[] {
             synchronizeHostData();
 
             let sourceFile = getValidSourceFile(fileName);
@@ -4887,8 +4966,8 @@ module ts {
                 if (symbol && symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
                     forEach(symbol.getDeclarations(), declaration => {
                         if (declaration.kind === SyntaxKind.ClassDeclaration) {
-                            getPropertySymbolFromTypeReference(getClassBaseTypeNode(<ClassDeclaration>declaration));
-                            forEach(getClassImplementedTypeNodes(<ClassDeclaration>declaration), getPropertySymbolFromTypeReference);
+                            getPropertySymbolFromTypeReference(getClassExtendsHeritageClauseElement(<ClassDeclaration>declaration));
+                            forEach(getClassImplementsHeritageClauseElements(<ClassDeclaration>declaration), getPropertySymbolFromTypeReference);
                         }
                         else if (declaration.kind === SyntaxKind.InterfaceDeclaration) {
                             forEach(getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration), getPropertySymbolFromTypeReference);
@@ -4897,7 +4976,7 @@ module ts {
                 }
                 return;
 
-                function getPropertySymbolFromTypeReference(typeReference: TypeReferenceNode) {
+                function getPropertySymbolFromTypeReference(typeReference: HeritageClauseElement) {
                     if (typeReference) {
                         let type = typeInfoResolver.getTypeAtLocation(typeReference);
                         if (type) {
@@ -5154,19 +5233,44 @@ module ts {
         }
 
         function isTypeReference(node: Node): boolean {
-            if (isRightSideOfQualifiedName(node)) {
+            if (isRightSideOfQualifiedNameOrPropertyAccess(node) ) {
                 node = node.parent;
             }
 
-            return node.parent.kind === SyntaxKind.TypeReference;
+            return node.parent.kind === SyntaxKind.TypeReference || node.parent.kind === SyntaxKind.HeritageClauseElement;
         }
 
         function isNamespaceReference(node: Node): boolean {
+            return isQualifiedNameNamespaceReference(node) || isPropertyAccessNamespaceReference(node);
+        }
+
+        function isPropertyAccessNamespaceReference(node: Node): boolean {
+            let root = node;
+            let isLastClause = true;
+            if (root.parent.kind === SyntaxKind.PropertyAccessExpression) {
+                while (root.parent && root.parent.kind === SyntaxKind.PropertyAccessExpression) {
+                    root = root.parent;
+                }
+
+                isLastClause = (<PropertyAccessExpression>root).name === node;
+            }
+
+            if (!isLastClause && root.parent.kind === SyntaxKind.HeritageClauseElement && root.parent.parent.kind === SyntaxKind.HeritageClause) {
+                let decl = root.parent.parent.parent;
+                return (decl.kind === SyntaxKind.ClassDeclaration && (<HeritageClause>root.parent.parent).token === SyntaxKind.ImplementsKeyword) ||
+                    (decl.kind === SyntaxKind.InterfaceDeclaration && (<HeritageClause>root.parent.parent).token === SyntaxKind.ExtendsKeyword);
+            }
+
+            return false;
+        }
+
+        function isQualifiedNameNamespaceReference(node: Node): boolean {
             let root = node;
             let isLastClause = true;
             if (root.parent.kind === SyntaxKind.QualifiedName) {
-                while (root.parent && root.parent.kind === SyntaxKind.QualifiedName)
+                while (root.parent && root.parent.kind === SyntaxKind.QualifiedName) {
                     root = root.parent;
+                }
 
                 isLastClause = (<QualifiedName>root).right === node;
             }

tests/baselines/reference/2dArrays.js

@@ -30,9 +30,7 @@ var Board = (function () {
     function Board() {
     }
     Board.prototype.allShipsSunk = function () {
-        return this.ships.every(function (val) {
-            return val.isSunk;
-        });
+        return this.ships.every(function (val) { return val.isSunk; });
     };
     return Board;
 })();

tests/baselines/reference/APISample_compile.js

@@ -233,59 +233,62 @@ declare module "typescript" {
         TemplateExpression = 171,
         YieldExpression = 172,
         SpreadElementExpression = 173,
-        OmittedExpression = 174,
-        TemplateSpan = 175,
-        Block = 176,
-        VariableStatement = 177,
-        EmptyStatement = 178,
-        ExpressionStatement = 179,
-        IfStatement = 180,
-        DoStatement = 181,
-        WhileStatement = 182,
-        ForStatement = 183,
-        ForInStatement = 184,
-        ForOfStatement = 185,
-        ContinueStatement = 186,
-        BreakStatement = 187,
-        ReturnStatement = 188,
-        WithStatement = 189,
-        SwitchStatement = 190,
-        LabeledStatement = 191,
-        ThrowStatement = 192,
-        TryStatement = 193,
-        DebuggerStatement = 194,
-        VariableDeclaration = 195,
-        VariableDeclarationList = 196,
-        FunctionDeclaration = 197,
-        ClassDeclaration = 198,
-        InterfaceDeclaration = 199,
-        TypeAliasDeclaration = 200,
-        EnumDeclaration = 201,
-        ModuleDeclaration = 202,
-        ModuleBlock = 203,
-        CaseBlock = 204,
-        ImportEqualsDeclaration = 205,
-        ImportDeclaration = 206,
-        ImportClause = 207,
-        NamespaceImport = 208,
-        NamedImports = 209,
-        ImportSpecifier = 210,
-        ExportAssignment = 211,
-        ExportDeclaration = 212,
-        NamedExports = 213,
-        ExportSpecifier = 214,
-        MissingDeclaration = 215,
-        ExternalModuleReference = 216,
-        CaseClause = 217,
-        DefaultClause = 218,
-        HeritageClause = 219,
-        CatchClause = 220,
-        PropertyAssignment = 221,
-        ShorthandPropertyAssignment = 222,
-        EnumMember = 223,
-        SourceFile = 224,
-        SyntaxList = 225,
-        Count = 226,
+        ClassExpression = 174,
+        OmittedExpression = 175,
+        TemplateSpan = 176,
+        HeritageClauseElement = 177,
+        SemicolonClassElement = 178,
+        Block = 179,
+        VariableStatement = 180,
+        EmptyStatement = 181,
+        ExpressionStatement = 182,
+        IfStatement = 183,
+        DoStatement = 184,
+        WhileStatement = 185,
+        ForStatement = 186,
+        ForInStatement = 187,
+        ForOfStatement = 188,
+        ContinueStatement = 189,
+        BreakStatement = 190,
+        ReturnStatement = 191,
+        WithStatement = 192,
+        SwitchStatement = 193,
+        LabeledStatement = 194,
+        ThrowStatement = 195,
+        TryStatement = 196,
+        DebuggerStatement = 197,
+        VariableDeclaration = 198,
+        VariableDeclarationList = 199,
+        FunctionDeclaration = 200,
+        ClassDeclaration = 201,
+        InterfaceDeclaration = 202,
+        TypeAliasDeclaration = 203,
+        EnumDeclaration = 204,
+        ModuleDeclaration = 205,
+        ModuleBlock = 206,
+        CaseBlock = 207,
+        ImportEqualsDeclaration = 208,
+        ImportDeclaration = 209,
+        ImportClause = 210,
+        NamespaceImport = 211,
+        NamedImports = 212,
+        ImportSpecifier = 213,
+        ExportAssignment = 214,
+        ExportDeclaration = 215,
+        NamedExports = 216,
+        ExportSpecifier = 217,
+        MissingDeclaration = 218,
+        ExternalModuleReference = 219,
+        CaseClause = 220,
+        DefaultClause = 221,
+        HeritageClause = 222,
+        CatchClause = 223,
+        PropertyAssignment = 224,
+        ShorthandPropertyAssignment = 225,
+        EnumMember = 226,
+        SourceFile = 227,
+        SyntaxList = 228,
+        Count = 229,
         FirstAssignment = 53,
         LastAssignment = 64,
         FirstReservedWord = 66,
@@ -469,6 +472,9 @@ declare module "typescript" {
     interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {
         body?: Block;
     }
+    interface SemicolonClassElement extends ClassElement {
+        _semicolonClassElementBrand: any;
+    }
     interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
         _accessorDeclarationBrand: any;
         body: Block;
@@ -607,6 +613,10 @@ declare module "typescript" {
         typeArguments?: NodeArray<TypeNode>;
         arguments: NodeArray<Expression>;
     }
+    interface HeritageClauseElement extends Node {
+        expression: LeftHandSideExpression;
+        typeArguments?: NodeArray<TypeNode>;
+    }
     interface NewExpression extends CallExpression, PrimaryExpression {
     }
     interface TaggedTemplateExpression extends MemberExpression {
@@ -701,12 +711,16 @@ declare module "typescript" {
     interface ModuleElement extends Node {
         _moduleElementBrand: any;
     }
-    interface ClassDeclaration extends Declaration, ModuleElement {
+    interface ClassLikeDeclaration extends Declaration {
         name?: Identifier;
         typeParameters?: NodeArray<TypeParameterDeclaration>;
         heritageClauses?: NodeArray<HeritageClause>;
         members: NodeArray<ClassElement>;
     }
+    interface ClassDeclaration extends ClassLikeDeclaration, Statement {
+    }
+    interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
+    }
     interface ClassElement extends Declaration {
         _classElementBrand: any;
     }
@@ -718,7 +732,7 @@ declare module "typescript" {
     }
     interface HeritageClause extends Node {
         token: SyntaxKind;
-        types?: NodeArray<TypeReferenceNode>;
+        types?: NodeArray<HeritageClauseElement>;
     }
     interface TypeAliasDeclaration extends Declaration, ModuleElement {
         name: Identifier;
@@ -960,7 +974,7 @@ declare module "typescript" {
         writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
-        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
+        isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
         resolvesToSomeValue(location: Node, name: string): boolean;
         getBlockScopedVariableId(node: Identifier): number;
@@ -1216,7 +1230,6 @@ declare module "typescript" {
     interface CompilerOptions {
         allowNonTsExtensions?: boolean;
         charset?: string;
-        codepage?: number;
         declaration?: boolean;
         diagnostics?: boolean;
         emitBOM?: boolean;
@@ -1230,7 +1243,6 @@ declare module "typescript" {
         noErrorTruncation?: boolean;
         noImplicitAny?: boolean;
         noLib?: boolean;
-        noLibCheck?: boolean;
         noResolve?: boolean;
         out?: string;
         outDir?: string;
@@ -1243,6 +1255,7 @@ declare module "typescript" {
         target?: ScriptTarget;
         version?: boolean;
         watch?: boolean;
+        separateCompilation?: boolean;
         [option: string]: string | number | boolean;
     }
     const enum ModuleKind {
@@ -1491,6 +1504,20 @@ declare module "typescript" {
     function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
     function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost): Program;
 }
+declare module "typescript" {
+    /**
+      * Read tsconfig.json file
+      * @param fileName The path to the config file
+      */
+    function readConfigFile(fileName: string): any;
+    /**
+      * Parse the contents of a config file (tsconfig.json).
+      * @param json The contents of the config file to parse
+      * @param basePath A root directory to resolve relative path entries in the config
+      *    file to. e.g. outDir
+      */
+    function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
+}
 declare module "typescript" {
     /** The version of the language service API */
     let servicesVersion: string;
@@ -1984,6 +2011,7 @@ declare module "typescript" {
         isCancellationRequested(): boolean;
         throwIfCancellationRequested(): void;
     }
+    function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
     function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
     let disableIncrementalParsing: boolean;
     function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
@@ -2021,8 +2049,6 @@ function compile(fileNames, options) {
 }
 exports.compile = compile;
 compile(process.argv.slice(2), {
-    noEmitOnError: true,
-    noImplicitAny: true,
-    target: 1 /* ES5 */,
-    module: 1 /* CommonJS */
+    noEmitOnError: true, noImplicitAny: true,
+    target: 1 /* ES5 */, module: 1 /* CommonJS */
 });

tests/baselines/reference/APISample_compile.types

@@ -717,163 +717,172 @@ declare module "typescript" {
         SpreadElementExpression = 173,
 >SpreadElementExpression : SyntaxKind
 
-        OmittedExpression = 174,
+        ClassExpression = 174,
+>ClassExpression : SyntaxKind
+
+        OmittedExpression = 175,
 >OmittedExpression : SyntaxKind
 
-        TemplateSpan = 175,
+        TemplateSpan = 176,
 >TemplateSpan : SyntaxKind
 
-        Block = 176,
+        HeritageClauseElement = 177,
+>HeritageClauseElement : SyntaxKind
+
+        SemicolonClassElement = 178,
+>SemicolonClassElement : SyntaxKind
+
+        Block = 179,
 >Block : SyntaxKind
 
-        VariableStatement = 177,
+        VariableStatement = 180,
 >VariableStatement : SyntaxKind
 
-        EmptyStatement = 178,
+        EmptyStatement = 181,
 >EmptyStatement : SyntaxKind
 
-        ExpressionStatement = 179,
+        ExpressionStatement = 182,
 >ExpressionStatement : SyntaxKind
 
-        IfStatement = 180,
+        IfStatement = 183,
 >IfStatement : SyntaxKind
 
-        DoStatement = 181,
+        DoStatement = 184,
 >DoStatement : SyntaxKind
 
-        WhileStatement = 182,
+        WhileStatement = 185,
 >WhileStatement : SyntaxKind
 
-        ForStatement = 183,
+        ForStatement = 186,
 >ForStatement : SyntaxKind
 
-        ForInStatement = 184,
+        ForInStatement = 187,
 >ForInStatement : SyntaxKind
 
-        ForOfStatement = 185,
+        ForOfStatement = 188,
 >ForOfStatement : SyntaxKind
 
-        ContinueStatement = 186,
+        ContinueStatement = 189,
 >ContinueStatement : SyntaxKind
 
-        BreakStatement = 187,
+        BreakStatement = 190,
 >BreakStatement : SyntaxKind
 
-        ReturnStatement = 188,
+        ReturnStatement = 191,
 >ReturnStatement : SyntaxKind
 
-        WithStatement = 189,
+        WithStatement = 192,
 >WithStatement : SyntaxKind
 
-        SwitchStatement = 190,
+        SwitchStatement = 193,
 >SwitchStatement : SyntaxKind
 
-        LabeledStatement = 191,
+        LabeledStatement = 194,
 >LabeledStatement : SyntaxKind
 
-        ThrowStatement = 192,
+        ThrowStatement = 195,
 >ThrowStatement : SyntaxKind
 
-        TryStatement = 193,
+        TryStatement = 196,
 >TryStatement : SyntaxKind
 
-        DebuggerStatement = 194,
+        DebuggerStatement = 197,
 >DebuggerStatement : SyntaxKind
 
-        VariableDeclaration = 195,
+        VariableDeclaration = 198,
 >VariableDeclaration : SyntaxKind
 
-        VariableDeclarationList = 196,
+        VariableDeclarationList = 199,
 >VariableDeclarationList : SyntaxKind
 
-        FunctionDeclaration = 197,
+        FunctionDeclaration = 200,
 >FunctionDeclaration : SyntaxKind
 
-        ClassDeclaration = 198,
+        ClassDeclaration = 201,
 >ClassDeclaration : SyntaxKind
 
-        InterfaceDeclaration = 199,
+        InterfaceDeclaration = 202,
 >InterfaceDeclaration : SyntaxKind
 
-        TypeAliasDeclaration = 200,
+        TypeAliasDeclaration = 203,
 >TypeAliasDeclaration : SyntaxKind
 
-        EnumDeclaration = 201,
+        EnumDeclaration = 204,
 >EnumDeclaration : SyntaxKind
 
-        ModuleDeclaration = 202,
+        ModuleDeclaration = 205,
 >ModuleDeclaration : SyntaxKind
 
-        ModuleBlock = 203,
+        ModuleBlock = 206,
 >ModuleBlock : SyntaxKind
 
-        CaseBlock = 204,
+        CaseBlock = 207,
 >CaseBlock : SyntaxKind
 
-        ImportEqualsDeclaration = 205,
+        ImportEqualsDeclaration = 208,
 >ImportEqualsDeclaration : SyntaxKind
 
-        ImportDeclaration = 206,
+        ImportDeclaration = 209,
 >ImportDeclaration : SyntaxKind
 
-        ImportClause = 207,
+        ImportClause = 210,
 >ImportClause : SyntaxKind
 
-        NamespaceImport = 208,
+        NamespaceImport = 211,
 >NamespaceImport : SyntaxKind
 
-        NamedImports = 209,
+        NamedImports = 212,
 >NamedImports : SyntaxKind
 
-        ImportSpecifier = 210,
+        ImportSpecifier = 213,
 >ImportSpecifier : SyntaxKind
 
-        ExportAssignment = 211,
+        ExportAssignment = 214,
 >ExportAssignment : SyntaxKind
 
-        ExportDeclaration = 212,
+        ExportDeclaration = 215,
 >ExportDeclaration : SyntaxKind
 
-        NamedExports = 213,
+        NamedExports = 216,
 >NamedExports : SyntaxKind
 
-        ExportSpecifier = 214,
+        ExportSpecifier = 217,
 >ExportSpecifier : SyntaxKind
 
-        MissingDeclaration = 215,
+        MissingDeclaration = 218,
 >MissingDeclaration : SyntaxKind
 
-        ExternalModuleReference = 216,
+        ExternalModuleReference = 219,
 >ExternalModuleReference : SyntaxKind
 
-        CaseClause = 217,
+        CaseClause = 220,
 >CaseClause : SyntaxKind
 
-        DefaultClause = 218,
+        DefaultClause = 221,
 >DefaultClause : SyntaxKind
 
-        HeritageClause = 219,
+        HeritageClause = 222,
 >HeritageClause : SyntaxKind
 
-        CatchClause = 220,
+        CatchClause = 223,
 >CatchClause : SyntaxKind
 
-        PropertyAssignment = 221,
+        PropertyAssignment = 224,
 >PropertyAssignment : SyntaxKind
 
-        ShorthandPropertyAssignment = 222,
+        ShorthandPropertyAssignment = 225,
 >ShorthandPropertyAssignment : SyntaxKind
 
-        EnumMember = 223,
+        EnumMember = 226,
 >EnumMember : SyntaxKind
 
-        SourceFile = 224,
+        SourceFile = 227,
 >SourceFile : SyntaxKind
 
-        SyntaxList = 225,
+        SyntaxList = 228,
 >SyntaxList : SyntaxKind
 
-        Count = 226,
+        Count = 229,
 >Count : SyntaxKind
 
         FirstAssignment = 53,
@@ -1430,6 +1439,13 @@ declare module "typescript" {
         body?: Block;
 >body : Block
 >Block : Block
+    }
+    interface SemicolonClassElement extends ClassElement {
+>SemicolonClassElement : SemicolonClassElement
+>ClassElement : ClassElement
+
+        _semicolonClassElementBrand: any;
+>_semicolonClassElementBrand : any
     }
     interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
 >AccessorDeclaration : AccessorDeclaration
@@ -1831,6 +1847,19 @@ declare module "typescript" {
 >arguments : NodeArray<Expression>
 >NodeArray : NodeArray<T>
 >Expression : Expression
+    }
+    interface HeritageClauseElement extends Node {
+>HeritageClauseElement : HeritageClauseElement
+>Node : Node
+
+        expression: LeftHandSideExpression;
+>expression : LeftHandSideExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        typeArguments?: NodeArray<TypeNode>;
+>typeArguments : NodeArray<TypeNode>
+>NodeArray : NodeArray<T>
+>TypeNode : TypeNode
     }
     interface NewExpression extends CallExpression, PrimaryExpression {
 >NewExpression : NewExpression
@@ -2115,10 +2144,9 @@ declare module "typescript" {
         _moduleElementBrand: any;
 >_moduleElementBrand : any
     }
-    interface ClassDeclaration extends Declaration, ModuleElement {
->ClassDeclaration : ClassDeclaration
+    interface ClassLikeDeclaration extends Declaration {
+>ClassLikeDeclaration : ClassLikeDeclaration
 >Declaration : Declaration
->ModuleElement : ModuleElement
 
         name?: Identifier;
 >name : Identifier
@@ -2138,6 +2166,16 @@ declare module "typescript" {
 >members : NodeArray<ClassElement>
 >NodeArray : NodeArray<T>
 >ClassElement : ClassElement
+    }
+    interface ClassDeclaration extends ClassLikeDeclaration, Statement {
+>ClassDeclaration : ClassDeclaration
+>ClassLikeDeclaration : ClassLikeDeclaration
+>Statement : Statement
+    }
+    interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
+>ClassExpression : ClassExpression
+>ClassLikeDeclaration : ClassLikeDeclaration
+>PrimaryExpression : PrimaryExpression
     }
     interface ClassElement extends Declaration {
 >ClassElement : ClassElement
@@ -2178,10 +2216,10 @@ declare module "typescript" {
 >token : SyntaxKind
 >SyntaxKind : SyntaxKind
 
-        types?: NodeArray<TypeReferenceNode>;
->types : NodeArray<TypeReferenceNode>
+        types?: NodeArray<HeritageClauseElement>;
+>types : NodeArray<HeritageClauseElement>
 >NodeArray : NodeArray<T>
->TypeReferenceNode : TypeReferenceNode
+>HeritageClauseElement : HeritageClauseElement
     }
     interface TypeAliasDeclaration extends Declaration, ModuleElement {
 >TypeAliasDeclaration : TypeAliasDeclaration
@@ -3124,10 +3162,11 @@ declare module "typescript" {
 >SymbolFlags : SymbolFlags
 >SymbolAccessiblityResult : SymbolAccessiblityResult
 
-        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
->isEntityNameVisible : (entityName: Identifier | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
->entityName : Identifier | QualifiedName
+        isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
+>isEntityNameVisible : (entityName: Identifier | Expression | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
+>entityName : Identifier | Expression | QualifiedName
 >EntityName : Identifier | QualifiedName
+>Expression : Expression
 >enclosingDeclaration : Node
 >Node : Node
 >SymbolVisibilityResult : SymbolVisibilityResult
@@ -3900,9 +3939,6 @@ declare module "typescript" {
         charset?: string;
 >charset : string
 
-        codepage?: number;
->codepage : number
-
         declaration?: boolean;
 >declaration : boolean
 
@@ -3943,9 +3979,6 @@ declare module "typescript" {
         noLib?: boolean;
 >noLib : boolean
 
-        noLibCheck?: boolean;
->noLibCheck : boolean
-
         noResolve?: boolean;
 >noResolve : boolean
 
@@ -3983,6 +4016,9 @@ declare module "typescript" {
         watch?: boolean;
 >watch : boolean
 
+        separateCompilation?: boolean;
+>separateCompilation : boolean
+
         [option: string]: string | number | boolean;
 >option : string
     }
@@ -4801,6 +4837,27 @@ declare module "typescript" {
 >CompilerHost : CompilerHost
 >Program : Program
 }
+declare module "typescript" {
+    /**
+      * Read tsconfig.json file
+      * @param fileName The path to the config file
+      */
+    function readConfigFile(fileName: string): any;
+>readConfigFile : (fileName: string) => any
+>fileName : string
+
+    /**
+      * Parse the contents of a config file (tsconfig.json).
+      * @param json The contents of the config file to parse
+      * @param basePath A root directory to resolve relative path entries in the config
+      *    file to. e.g. outDir
+      */
+    function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
+>parseConfigFile : (json: any, basePath?: string) => ParsedCommandLine
+>json : any
+>basePath : string
+>ParsedCommandLine : ParsedCommandLine
+}
 declare module "typescript" {
     /** The version of the language service API */
     let servicesVersion: string;
@@ -6159,6 +6216,15 @@ declare module "typescript" {
         throwIfCancellationRequested(): void;
 >throwIfCancellationRequested : () => void
     }
+    function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
+>transpile : (input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]) => string
+>input : string
+>compilerOptions : CompilerOptions
+>CompilerOptions : CompilerOptions
+>fileName : string
+>diagnostics : Diagnostic[]
+>Diagnostic : Diagnostic
+
     function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
 >createLanguageServiceSourceFile : (fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean) => SourceFile
 >fileName : string

tests/baselines/reference/APISample_linter.js

@@ -264,59 +264,62 @@ declare module "typescript" {
         TemplateExpression = 171,
         YieldExpression = 172,
         SpreadElementExpression = 173,
-        OmittedExpression = 174,
-        TemplateSpan = 175,
-        Block = 176,
-        VariableStatement = 177,
-        EmptyStatement = 178,
-        ExpressionStatement = 179,
-        IfStatement = 180,
-        DoStatement = 181,
-        WhileStatement = 182,
-        ForStatement = 183,
-        ForInStatement = 184,
-        ForOfStatement = 185,
-        ContinueStatement = 186,
-        BreakStatement = 187,
-        ReturnStatement = 188,
-        WithStatement = 189,
-        SwitchStatement = 190,
-        LabeledStatement = 191,
-        ThrowStatement = 192,
-        TryStatement = 193,
-        DebuggerStatement = 194,
-        VariableDeclaration = 195,
-        VariableDeclarationList = 196,
-        FunctionDeclaration = 197,
-        ClassDeclaration = 198,
-        InterfaceDeclaration = 199,
-        TypeAliasDeclaration = 200,
-        EnumDeclaration = 201,
-        ModuleDeclaration = 202,
-        ModuleBlock = 203,
-        CaseBlock = 204,
-        ImportEqualsDeclaration = 205,
-        ImportDeclaration = 206,
-        ImportClause = 207,
-        NamespaceImport = 208,
-        NamedImports = 209,
-        ImportSpecifier = 210,
-        ExportAssignment = 211,
-        ExportDeclaration = 212,
-        NamedExports = 213,
-        ExportSpecifier = 214,
-        MissingDeclaration = 215,
-        ExternalModuleReference = 216,
-        CaseClause = 217,
-        DefaultClause = 218,
-        HeritageClause = 219,
-        CatchClause = 220,
-        PropertyAssignment = 221,
-        ShorthandPropertyAssignment = 222,
-        EnumMember = 223,
-        SourceFile = 224,
-        SyntaxList = 225,
-        Count = 226,
+        ClassExpression = 174,
+        OmittedExpression = 175,
+        TemplateSpan = 176,
+        HeritageClauseElement = 177,
+        SemicolonClassElement = 178,
+        Block = 179,
+        VariableStatement = 180,
+        EmptyStatement = 181,
+        ExpressionStatement = 182,
+        IfStatement = 183,
+        DoStatement = 184,
+        WhileStatement = 185,
+        ForStatement = 186,
+        ForInStatement = 187,
+        ForOfStatement = 188,
+        ContinueStatement = 189,
+        BreakStatement = 190,
+        ReturnStatement = 191,
+        WithStatement = 192,
+        SwitchStatement = 193,
+        LabeledStatement = 194,
+        ThrowStatement = 195,
+        TryStatement = 196,
+        DebuggerStatement = 197,
+        VariableDeclaration = 198,
+        VariableDeclarationList = 199,
+        FunctionDeclaration = 200,
+        ClassDeclaration = 201,
+        InterfaceDeclaration = 202,
+        TypeAliasDeclaration = 203,
+        EnumDeclaration = 204,
+        ModuleDeclaration = 205,
+        ModuleBlock = 206,
+        CaseBlock = 207,
+        ImportEqualsDeclaration = 208,
+        ImportDeclaration = 209,
+        ImportClause = 210,
+        NamespaceImport = 211,
+        NamedImports = 212,
+        ImportSpecifier = 213,
+        ExportAssignment = 214,
+        ExportDeclaration = 215,
+        NamedExports = 216,
+        ExportSpecifier = 217,
+        MissingDeclaration = 218,
+        ExternalModuleReference = 219,
+        CaseClause = 220,
+        DefaultClause = 221,
+        HeritageClause = 222,
+        CatchClause = 223,
+        PropertyAssignment = 224,
+        ShorthandPropertyAssignment = 225,
+        EnumMember = 226,
+        SourceFile = 227,
+        SyntaxList = 228,
+        Count = 229,
         FirstAssignment = 53,
         LastAssignment = 64,
         FirstReservedWord = 66,
@@ -500,6 +503,9 @@ declare module "typescript" {
     interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {
         body?: Block;
     }
+    interface SemicolonClassElement extends ClassElement {
+        _semicolonClassElementBrand: any;
+    }
     interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
         _accessorDeclarationBrand: any;
         body: Block;
@@ -638,6 +644,10 @@ declare module "typescript" {
         typeArguments?: NodeArray<TypeNode>;
         arguments: NodeArray<Expression>;
     }
+    interface HeritageClauseElement extends Node {
+        expression: LeftHandSideExpression;
+        typeArguments?: NodeArray<TypeNode>;
+    }
     interface NewExpression extends CallExpression, PrimaryExpression {
     }
     interface TaggedTemplateExpression extends MemberExpression {
@@ -732,12 +742,16 @@ declare module "typescript" {
     interface ModuleElement extends Node {
         _moduleElementBrand: any;
     }
-    interface ClassDeclaration extends Declaration, ModuleElement {
+    interface ClassLikeDeclaration extends Declaration {
         name?: Identifier;
         typeParameters?: NodeArray<TypeParameterDeclaration>;
         heritageClauses?: NodeArray<HeritageClause>;
         members: NodeArray<ClassElement>;
     }
+    interface ClassDeclaration extends ClassLikeDeclaration, Statement {
+    }
+    interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
+    }
     interface ClassElement extends Declaration {
         _classElementBrand: any;
     }
@@ -749,7 +763,7 @@ declare module "typescript" {
     }
     interface HeritageClause extends Node {
         token: SyntaxKind;
-        types?: NodeArray<TypeReferenceNode>;
+        types?: NodeArray<HeritageClauseElement>;
     }
     interface TypeAliasDeclaration extends Declaration, ModuleElement {
         name: Identifier;
@@ -991,7 +1005,7 @@ declare module "typescript" {
         writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
-        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
+        isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
         resolvesToSomeValue(location: Node, name: string): boolean;
         getBlockScopedVariableId(node: Identifier): number;
@@ -1247,7 +1261,6 @@ declare module "typescript" {
     interface CompilerOptions {
         allowNonTsExtensions?: boolean;
         charset?: string;
-        codepage?: number;
         declaration?: boolean;
         diagnostics?: boolean;
         emitBOM?: boolean;
@@ -1261,7 +1274,6 @@ declare module "typescript" {
         noErrorTruncation?: boolean;
         noImplicitAny?: boolean;
         noLib?: boolean;
-        noLibCheck?: boolean;
         noResolve?: boolean;
         out?: string;
         outDir?: string;
@@ -1274,6 +1286,7 @@ declare module "typescript" {
         target?: ScriptTarget;
         version?: boolean;
         watch?: boolean;
+        separateCompilation?: boolean;
         [option: string]: string | number | boolean;
     }
     const enum ModuleKind {
@@ -1522,6 +1535,20 @@ declare module "typescript" {
     function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
     function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost): Program;
 }
+declare module "typescript" {
+    /**
+      * Read tsconfig.json file
+      * @param fileName The path to the config file
+      */
+    function readConfigFile(fileName: string): any;
+    /**
+      * Parse the contents of a config file (tsconfig.json).
+      * @param json The contents of the config file to parse
+      * @param basePath A root directory to resolve relative path entries in the config
+      *    file to. e.g. outDir
+      */
+    function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
+}
 declare module "typescript" {
     /** The version of the language service API */
     let servicesVersion: string;
@@ -2015,6 +2042,7 @@ declare module "typescript" {
         isCancellationRequested(): boolean;
         throwIfCancellationRequested(): void;
     }
+    function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
     function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
     let disableIncrementalParsing: boolean;
     function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
@@ -2042,20 +2070,21 @@ function delint(sourceFile) {
     delintNode(sourceFile);
     function delintNode(node) {
         switch (node.kind) {
-            case 183 /* ForStatement */:
-            case 184 /* ForInStatement */:
-            case 182 /* WhileStatement */:
-            case 181 /* DoStatement */:
-                if (node.statement.kind !== 176 /* Block */) {
+            case 186 /* ForStatement */:
+            case 187 /* ForInStatement */:
+            case 185 /* WhileStatement */:
+            case 184 /* DoStatement */:
+                if (node.statement.kind !== 179 /* Block */) {
                     report(node, "A looping statement's contents should be wrapped in a block body.");
                 }
                 break;
-            case 180 /* IfStatement */:
+            case 183 /* IfStatement */:
                 var ifStatement = node;
-                if (ifStatement.thenStatement.kind !== 176 /* Block */) {
+                if (ifStatement.thenStatement.kind !== 179 /* Block */) {
                     report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body.");
                 }
-                if (ifStatement.elseStatement && ifStatement.elseStatement.kind !== 176 /* Block */ && ifStatement.elseStatement.kind !== 180 /* IfStatement */) {
+                if (ifStatement.elseStatement &&
+                    ifStatement.elseStatement.kind !== 179 /* Block */ && ifStatement.elseStatement.kind !== 183 /* IfStatement */) {
                     report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body.");
                 }
                 break;

tests/baselines/reference/APISample_linter.types

@@ -863,163 +863,172 @@ declare module "typescript" {
         SpreadElementExpression = 173,
 >SpreadElementExpression : SyntaxKind
 
-        OmittedExpression = 174,
+        ClassExpression = 174,
+>ClassExpression : SyntaxKind
+
+        OmittedExpression = 175,
 >OmittedExpression : SyntaxKind
 
-        TemplateSpan = 175,
+        TemplateSpan = 176,
 >TemplateSpan : SyntaxKind
 
-        Block = 176,
+        HeritageClauseElement = 177,
+>HeritageClauseElement : SyntaxKind
+
+        SemicolonClassElement = 178,
+>SemicolonClassElement : SyntaxKind
+
+        Block = 179,
 >Block : SyntaxKind
 
-        VariableStatement = 177,
+        VariableStatement = 180,
 >VariableStatement : SyntaxKind
 
-        EmptyStatement = 178,
+        EmptyStatement = 181,
 >EmptyStatement : SyntaxKind
 
-        ExpressionStatement = 179,
+        ExpressionStatement = 182,
 >ExpressionStatement : SyntaxKind
 
-        IfStatement = 180,
+        IfStatement = 183,
 >IfStatement : SyntaxKind
 
-        DoStatement = 181,
+        DoStatement = 184,
 >DoStatement : SyntaxKind
 
-        WhileStatement = 182,
+        WhileStatement = 185,
 >WhileStatement : SyntaxKind
 
-        ForStatement = 183,
+        ForStatement = 186,
 >ForStatement : SyntaxKind
 
-        ForInStatement = 184,
+        ForInStatement = 187,
 >ForInStatement : SyntaxKind
 
-        ForOfStatement = 185,
+        ForOfStatement = 188,
 >ForOfStatement : SyntaxKind
 
-        ContinueStatement = 186,
+        ContinueStatement = 189,
 >ContinueStatement : SyntaxKind
 
-        BreakStatement = 187,
+        BreakStatement = 190,
 >BreakStatement : SyntaxKind
 
-        ReturnStatement = 188,
+        ReturnStatement = 191,
 >ReturnStatement : SyntaxKind
 
-        WithStatement = 189,
+        WithStatement = 192,
 >WithStatement : SyntaxKind
 
-        SwitchStatement = 190,
+        SwitchStatement = 193,
 >SwitchStatement : SyntaxKind
 
-        LabeledStatement = 191,
+        LabeledStatement = 194,
 >LabeledStatement : SyntaxKind
 
-        ThrowStatement = 192,
+        ThrowStatement = 195,
 >ThrowStatement : SyntaxKind
 
-        TryStatement = 193,
+        TryStatement = 196,
 >TryStatement : SyntaxKind
 
-        DebuggerStatement = 194,
+        DebuggerStatement = 197,
 >DebuggerStatement : SyntaxKind
 
-        VariableDeclaration = 195,
+        VariableDeclaration = 198,
 >VariableDeclaration : SyntaxKind
 
-        VariableDeclarationList = 196,
+        VariableDeclarationList = 199,
 >VariableDeclarationList : SyntaxKind
 
-        FunctionDeclaration = 197,
+        FunctionDeclaration = 200,
 >FunctionDeclaration : SyntaxKind
 
-        ClassDeclaration = 198,
+        ClassDeclaration = 201,
 >ClassDeclaration : SyntaxKind
 
-        InterfaceDeclaration = 199,
+        InterfaceDeclaration = 202,
 >InterfaceDeclaration : SyntaxKind
 
-        TypeAliasDeclaration = 200,
+        TypeAliasDeclaration = 203,
 >TypeAliasDeclaration : SyntaxKind
 
-        EnumDeclaration = 201,
+        EnumDeclaration = 204,
 >EnumDeclaration : SyntaxKind
 
-        ModuleDeclaration = 202,
+        ModuleDeclaration = 205,
 >ModuleDeclaration : SyntaxKind
 
-        ModuleBlock = 203,
+        ModuleBlock = 206,
 >ModuleBlock : SyntaxKind
 
-        CaseBlock = 204,
+        CaseBlock = 207,
 >CaseBlock : SyntaxKind
 
-        ImportEqualsDeclaration = 205,
+        ImportEqualsDeclaration = 208,
 >ImportEqualsDeclaration : SyntaxKind
 
-        ImportDeclaration = 206,
+        ImportDeclaration = 209,
 >ImportDeclaration : SyntaxKind
 
-        ImportClause = 207,
+        ImportClause = 210,
 >ImportClause : SyntaxKind
 
-        NamespaceImport = 208,
+        NamespaceImport = 211,
 >NamespaceImport : SyntaxKind
 
-        NamedImports = 209,
+        NamedImports = 212,
 >NamedImports : SyntaxKind
 
-        ImportSpecifier = 210,
+        ImportSpecifier = 213,
 >ImportSpecifier : SyntaxKind
 
-        ExportAssignment = 211,
+        ExportAssignment = 214,
 >ExportAssignment : SyntaxKind
 
-        ExportDeclaration = 212,
+        ExportDeclaration = 215,
 >ExportDeclaration : SyntaxKind
 
-        NamedExports = 213,
+        NamedExports = 216,
 >NamedExports : SyntaxKind
 
-        ExportSpecifier = 214,
+        ExportSpecifier = 217,
 >ExportSpecifier : SyntaxKind
 
-        MissingDeclaration = 215,
+        MissingDeclaration = 218,
 >MissingDeclaration : SyntaxKind
 
-        ExternalModuleReference = 216,
+        ExternalModuleReference = 219,
 >ExternalModuleReference : SyntaxKind
 
-        CaseClause = 217,
+        CaseClause = 220,
 >CaseClause : SyntaxKind
 
-        DefaultClause = 218,
+        DefaultClause = 221,
 >DefaultClause : SyntaxKind
 
-        HeritageClause = 219,
+        HeritageClause = 222,
 >HeritageClause : SyntaxKind
 
-        CatchClause = 220,
+        CatchClause = 223,
 >CatchClause : SyntaxKind
 
-        PropertyAssignment = 221,
+        PropertyAssignment = 224,
 >PropertyAssignment : SyntaxKind
 
-        ShorthandPropertyAssignment = 222,
+        ShorthandPropertyAssignment = 225,
 >ShorthandPropertyAssignment : SyntaxKind
 
-        EnumMember = 223,
+        EnumMember = 226,
 >EnumMember : SyntaxKind
 
-        SourceFile = 224,
+        SourceFile = 227,
 >SourceFile : SyntaxKind
 
-        SyntaxList = 225,
+        SyntaxList = 228,
 >SyntaxList : SyntaxKind
 
-        Count = 226,
+        Count = 229,
 >Count : SyntaxKind
 
         FirstAssignment = 53,
@@ -1576,6 +1585,13 @@ declare module "typescript" {
         body?: Block;
 >body : Block
 >Block : Block
+    }
+    interface SemicolonClassElement extends ClassElement {
+>SemicolonClassElement : SemicolonClassElement
+>ClassElement : ClassElement
+
+        _semicolonClassElementBrand: any;
+>_semicolonClassElementBrand : any
     }
     interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
 >AccessorDeclaration : AccessorDeclaration
@@ -1977,6 +1993,19 @@ declare module "typescript" {
 >arguments : NodeArray<Expression>
 >NodeArray : NodeArray<T>
 >Expression : Expression
+    }
+    interface HeritageClauseElement extends Node {
+>HeritageClauseElement : HeritageClauseElement
+>Node : Node
+
+        expression: LeftHandSideExpression;
+>expression : LeftHandSideExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        typeArguments?: NodeArray<TypeNode>;
+>typeArguments : NodeArray<TypeNode>
+>NodeArray : NodeArray<T>
+>TypeNode : TypeNode
     }
     interface NewExpression extends CallExpression, PrimaryExpression {
 >NewExpression : NewExpression
@@ -2261,10 +2290,9 @@ declare module "typescript" {
         _moduleElementBrand: any;
 >_moduleElementBrand : any
     }
-    interface ClassDeclaration extends Declaration, ModuleElement {
->ClassDeclaration : ClassDeclaration
+    interface ClassLikeDeclaration extends Declaration {
+>ClassLikeDeclaration : ClassLikeDeclaration
 >Declaration : Declaration
->ModuleElement : ModuleElement
 
         name?: Identifier;
 >name : Identifier
@@ -2284,6 +2312,16 @@ declare module "typescript" {
 >members : NodeArray<ClassElement>
 >NodeArray : NodeArray<T>
 >ClassElement : ClassElement
+    }
+    interface ClassDeclaration extends ClassLikeDeclaration, Statement {
+>ClassDeclaration : ClassDeclaration
+>ClassLikeDeclaration : ClassLikeDeclaration
+>Statement : Statement
+    }
+    interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
+>ClassExpression : ClassExpression
+>ClassLikeDeclaration : ClassLikeDeclaration
+>PrimaryExpression : PrimaryExpression
     }
     interface ClassElement extends Declaration {
 >ClassElement : ClassElement
@@ -2324,10 +2362,10 @@ declare module "typescript" {
 >token : SyntaxKind
 >SyntaxKind : SyntaxKind
 
-        types?: NodeArray<TypeReferenceNode>;
->types : NodeArray<TypeReferenceNode>
+        types?: NodeArray<HeritageClauseElement>;
+>types : NodeArray<HeritageClauseElement>
 >NodeArray : NodeArray<T>
->TypeReferenceNode : TypeReferenceNode
+>HeritageClauseElement : HeritageClauseElement
     }
     interface TypeAliasDeclaration extends Declaration, ModuleElement {
 >TypeAliasDeclaration : TypeAliasDeclaration
@@ -3270,10 +3308,11 @@ declare module "typescript" {
 >SymbolFlags : SymbolFlags
 >SymbolAccessiblityResult : SymbolAccessiblityResult
 
-        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
->isEntityNameVisible : (entityName: Identifier | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
->entityName : Identifier | QualifiedName
+        isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
+>isEntityNameVisible : (entityName: Identifier | Expression | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
+>entityName : Identifier | Expression | QualifiedName
 >EntityName : Identifier | QualifiedName
+>Expression : Expression
 >enclosingDeclaration : Node
 >Node : Node
 >SymbolVisibilityResult : SymbolVisibilityResult
@@ -4046,9 +4085,6 @@ declare module "typescript" {
         charset?: string;
 >charset : string
 
-        codepage?: number;
->codepage : number
-
         declaration?: boolean;
 >declaration : boolean
 
@@ -4089,9 +4125,6 @@ declare module "typescript" {
         noLib?: boolean;
 >noLib : boolean
 
-        noLibCheck?: boolean;
->noLibCheck : boolean
-
         noResolve?: boolean;
 >noResolve : boolean
 
@@ -4129,6 +4162,9 @@ declare module "typescript" {
         watch?: boolean;
 >watch : boolean
 
+        separateCompilation?: boolean;
+>separateCompilation : boolean
+
         [option: string]: string | number | boolean;
 >option : string
     }
@@ -4947,6 +4983,27 @@ declare module "typescript" {
 >CompilerHost : CompilerHost
 >Program : Program
 }
+declare module "typescript" {
+    /**
+      * Read tsconfig.json file
+      * @param fileName The path to the config file
+      */
+    function readConfigFile(fileName: string): any;
+>readConfigFile : (fileName: string) => any
+>fileName : string
+
+    /**
+      * Parse the contents of a config file (tsconfig.json).
+      * @param json The contents of the config file to parse
+      * @param basePath A root directory to resolve relative path entries in the config
+      *    file to. e.g. outDir
+      */
+    function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
+>parseConfigFile : (json: any, basePath?: string) => ParsedCommandLine
+>json : any
+>basePath : string
+>ParsedCommandLine : ParsedCommandLine
+}
 declare module "typescript" {
     /** The version of the language service API */
     let servicesVersion: string;
@@ -6305,6 +6362,15 @@ declare module "typescript" {
         throwIfCancellationRequested(): void;
 >throwIfCancellationRequested : () => void
     }
+    function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
+>transpile : (input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]) => string
+>input : string
+>compilerOptions : CompilerOptions
+>CompilerOptions : CompilerOptions
+>fileName : string
+>diagnostics : Diagnostic[]
+>Diagnostic : Diagnostic
+
     function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
 >createLanguageServiceSourceFile : (fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean) => SourceFile
 >fileName : string

tests/baselines/reference/APISample_transform.js

@@ -265,59 +265,62 @@ declare module "typescript" {
         TemplateExpression = 171,
         YieldExpression = 172,
         SpreadElementExpression = 173,
-        OmittedExpression = 174,
-        TemplateSpan = 175,
-        Block = 176,
-        VariableStatement = 177,
-        EmptyStatement = 178,
-        ExpressionStatement = 179,
-        IfStatement = 180,
-        DoStatement = 181,
-        WhileStatement = 182,
-        ForStatement = 183,
-        ForInStatement = 184,
-        ForOfStatement = 185,
-        ContinueStatement = 186,
-        BreakStatement = 187,
-        ReturnStatement = 188,
-        WithStatement = 189,
-        SwitchStatement = 190,
-        LabeledStatement = 191,
-        ThrowStatement = 192,
-        TryStatement = 193,
-        DebuggerStatement = 194,
-        VariableDeclaration = 195,
-        VariableDeclarationList = 196,
-        FunctionDeclaration = 197,
-        ClassDeclaration = 198,
-        InterfaceDeclaration = 199,
-        TypeAliasDeclaration = 200,
-        EnumDeclaration = 201,
-        ModuleDeclaration = 202,
-        ModuleBlock = 203,
-        CaseBlock = 204,
-        ImportEqualsDeclaration = 205,
-        ImportDeclaration = 206,
-        ImportClause = 207,
-        NamespaceImport = 208,
-        NamedImports = 209,
-        ImportSpecifier = 210,
-        ExportAssignment = 211,
-        ExportDeclaration = 212,
-        NamedExports = 213,
-        ExportSpecifier = 214,
-        MissingDeclaration = 215,
-        ExternalModuleReference = 216,
-        CaseClause = 217,
-        DefaultClause = 218,
-        HeritageClause = 219,
-        CatchClause = 220,
-        PropertyAssignment = 221,
-        ShorthandPropertyAssignment = 222,
-        EnumMember = 223,
-        SourceFile = 224,
-        SyntaxList = 225,
-        Count = 226,
+        ClassExpression = 174,
+        OmittedExpression = 175,
+        TemplateSpan = 176,
+        HeritageClauseElement = 177,
+        SemicolonClassElement = 178,
+        Block = 179,
+        VariableStatement = 180,
+        EmptyStatement = 181,
+        ExpressionStatement = 182,
+        IfStatement = 183,
+        DoStatement = 184,
+        WhileStatement = 185,
+        ForStatement = 186,
+        ForInStatement = 187,
+        ForOfStatement = 188,
+        ContinueStatement = 189,
+        BreakStatement = 190,
+        ReturnStatement = 191,
+        WithStatement = 192,
+        SwitchStatement = 193,
+        LabeledStatement = 194,
+        ThrowStatement = 195,
+        TryStatement = 196,
+        DebuggerStatement = 197,
+        VariableDeclaration = 198,
+        VariableDeclarationList = 199,
+        FunctionDeclaration = 200,
+        ClassDeclaration = 201,
+        InterfaceDeclaration = 202,
+        TypeAliasDeclaration = 203,
+        EnumDeclaration = 204,
+        ModuleDeclaration = 205,
+        ModuleBlock = 206,
+        CaseBlock = 207,
+        ImportEqualsDeclaration = 208,
+        ImportDeclaration = 209,
+        ImportClause = 210,
+        NamespaceImport = 211,
+        NamedImports = 212,
+        ImportSpecifier = 213,
+        ExportAssignment = 214,
+        ExportDeclaration = 215,
+        NamedExports = 216,
+        ExportSpecifier = 217,
+        MissingDeclaration = 218,
+        ExternalModuleReference = 219,
+        CaseClause = 220,
+        DefaultClause = 221,
+        HeritageClause = 222,
+        CatchClause = 223,
+        PropertyAssignment = 224,
+        ShorthandPropertyAssignment = 225,
+        EnumMember = 226,
+        SourceFile = 227,
+        SyntaxList = 228,
+        Count = 229,
         FirstAssignment = 53,
         LastAssignment = 64,
         FirstReservedWord = 66,
@@ -501,6 +504,9 @@ declare module "typescript" {
     interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {
         body?: Block;
     }
+    interface SemicolonClassElement extends ClassElement {
+        _semicolonClassElementBrand: any;
+    }
     interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
         _accessorDeclarationBrand: any;
         body: Block;
@@ -639,6 +645,10 @@ declare module "typescript" {
         typeArguments?: NodeArray<TypeNode>;
         arguments: NodeArray<Expression>;
     }
+    interface HeritageClauseElement extends Node {
+        expression: LeftHandSideExpression;
+        typeArguments?: NodeArray<TypeNode>;
+    }
     interface NewExpression extends CallExpression, PrimaryExpression {
     }
     interface TaggedTemplateExpression extends MemberExpression {
@@ -733,12 +743,16 @@ declare module "typescript" {
     interface ModuleElement extends Node {
         _moduleElementBrand: any;
     }
-    interface ClassDeclaration extends Declaration, ModuleElement {
+    interface ClassLikeDeclaration extends Declaration {
         name?: Identifier;
         typeParameters?: NodeArray<TypeParameterDeclaration>;
         heritageClauses?: NodeArray<HeritageClause>;
         members: NodeArray<ClassElement>;
     }
+    interface ClassDeclaration extends ClassLikeDeclaration, Statement {
+    }
+    interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
+    }
     interface ClassElement extends Declaration {
         _classElementBrand: any;
     }
@@ -750,7 +764,7 @@ declare module "typescript" {
     }
     interface HeritageClause extends Node {
         token: SyntaxKind;
-        types?: NodeArray<TypeReferenceNode>;
+        types?: NodeArray<HeritageClauseElement>;
     }
     interface TypeAliasDeclaration extends Declaration, ModuleElement {
         name: Identifier;
@@ -992,7 +1006,7 @@ declare module "typescript" {
         writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
-        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
+        isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
         resolvesToSomeValue(location: Node, name: string): boolean;
         getBlockScopedVariableId(node: Identifier): number;
@@ -1248,7 +1262,6 @@ declare module "typescript" {
     interface CompilerOptions {
         allowNonTsExtensions?: boolean;
         charset?: string;
-        codepage?: number;
         declaration?: boolean;
         diagnostics?: boolean;
         emitBOM?: boolean;
@@ -1262,7 +1275,6 @@ declare module "typescript" {
         noErrorTruncation?: boolean;
         noImplicitAny?: boolean;
         noLib?: boolean;
-        noLibCheck?: boolean;
         noResolve?: boolean;
         out?: string;
         outDir?: string;
@@ -1275,6 +1287,7 @@ declare module "typescript" {
         target?: ScriptTarget;
         version?: boolean;
         watch?: boolean;
+        separateCompilation?: boolean;
         [option: string]: string | number | boolean;
     }
     const enum ModuleKind {
@@ -1523,6 +1536,20 @@ declare module "typescript" {
     function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
     function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost): Program;
 }
+declare module "typescript" {
+    /**
+      * Read tsconfig.json file
+      * @param fileName The path to the config file
+      */
+    function readConfigFile(fileName: string): any;
+    /**
+      * Parse the contents of a config file (tsconfig.json).
+      * @param json The contents of the config file to parse
+      * @param basePath A root directory to resolve relative path entries in the config
+      *    file to. e.g. outDir
+      */
+    function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
+}
 declare module "typescript" {
     /** The version of the language service API */
     let servicesVersion: string;
@@ -2016,6 +2043,7 @@ declare module "typescript" {
         isCancellationRequested(): boolean;
         throwIfCancellationRequested(): void;
     }
+    function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
     function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
     let disableIncrementalParsing: boolean;
     function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
@@ -2051,35 +2079,20 @@ function transform(contents, compilerOptions) {
     // Create a compilerHost object to allow the compiler to read and write files
     var compilerHost = {
         getSourceFile: function (fileName, target) {
-            return files[fileName] !== undefined ? ts.createSourceFile(fileName, files[fileName], target) : undefined;
+            return files[fileName] !== undefined ?
+                ts.createSourceFile(fileName, files[fileName], target) : undefined;
         },
         writeFile: function (name, text, writeByteOrderMark) {
-            outputs.push({
-                name: name,
-                text: text,
-                writeByteOrderMark: writeByteOrderMark
-            });
+            outputs.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark });
         },
-        getDefaultLibFileName: function () {
-            return "lib.d.ts";
-        },
-        useCaseSensitiveFileNames: function () {
-            return false;
-        },
-        getCanonicalFileName: function (fileName) {
-            return fileName;
-        },
-        getCurrentDirectory: function () {
-            return "";
-        },
-        getNewLine: function () {
-            return "\n";
-        }
+        getDefaultLibFileName: function () { return "lib.d.ts"; },
+        useCaseSensitiveFileNames: function () { return false; },
+        getCanonicalFileName: function (fileName) { return fileName; },
+        getCurrentDirectory: function () { return ""; },
+        getNewLine: function () { return "\n"; }
     };
     // Create a program from inputs
-    var program = ts.createProgram([
-        "file.ts"
-    ], compilerOptions, compilerHost);
+    var program = ts.createProgram(["file.ts"], compilerOptions, compilerHost);
     // Query for early errors
     var errors = ts.getPreEmitDiagnostics(program);
     var emitResult = program.emit();
@@ -2087,7 +2100,8 @@ function transform(contents, compilerOptions) {
     return {
         outputs: outputs,
         errors: errors.map(function (e) {
-            return e.file.fileName + "(" + (e.file.getLineAndCharacterOfPosition(e.start).line + 1) + "): " + ts.flattenDiagnosticMessageText(e.messageText, os.EOL);
+            return e.file.fileName + "(" + (e.file.getLineAndCharacterOfPosition(e.start).line + 1) + "): "
+                + ts.flattenDiagnosticMessageText(e.messageText, os.EOL);
         })
     };
 }

tests/baselines/reference/APISample_transform.types

@@ -813,163 +813,172 @@ declare module "typescript" {
         SpreadElementExpression = 173,
 >SpreadElementExpression : SyntaxKind
 
-        OmittedExpression = 174,
+        ClassExpression = 174,
+>ClassExpression : SyntaxKind
+
+        OmittedExpression = 175,
 >OmittedExpression : SyntaxKind
 
-        TemplateSpan = 175,
+        TemplateSpan = 176,
 >TemplateSpan : SyntaxKind
 
-        Block = 176,
+        HeritageClauseElement = 177,
+>HeritageClauseElement : SyntaxKind
+
+        SemicolonClassElement = 178,
+>SemicolonClassElement : SyntaxKind
+
+        Block = 179,
 >Block : SyntaxKind
 
-        VariableStatement = 177,
+        VariableStatement = 180,
 >VariableStatement : SyntaxKind
 
-        EmptyStatement = 178,
+        EmptyStatement = 181,
 >EmptyStatement : SyntaxKind
 
-        ExpressionStatement = 179,
+        ExpressionStatement = 182,
 >ExpressionStatement : SyntaxKind
 
-        IfStatement = 180,
+        IfStatement = 183,
 >IfStatement : SyntaxKind
 
-        DoStatement = 181,
+        DoStatement = 184,
 >DoStatement : SyntaxKind
 
-        WhileStatement = 182,
+        WhileStatement = 185,
 >WhileStatement : SyntaxKind
 
-        ForStatement = 183,
+        ForStatement = 186,
 >ForStatement : SyntaxKind
 
-        ForInStatement = 184,
+        ForInStatement = 187,
 >ForInStatement : SyntaxKind
 
-        ForOfStatement = 185,
+        ForOfStatement = 188,
 >ForOfStatement : SyntaxKind
 
-        ContinueStatement = 186,
+        ContinueStatement = 189,
 >ContinueStatement : SyntaxKind
 
-        BreakStatement = 187,
+        BreakStatement = 190,
 >BreakStatement : SyntaxKind
 
-        ReturnStatement = 188,
+        ReturnStatement = 191,
 >ReturnStatement : SyntaxKind
 
-        WithStatement = 189,
+        WithStatement = 192,
 >WithStatement : SyntaxKind
 
-        SwitchStatement = 190,
+        SwitchStatement = 193,
 >SwitchStatement : SyntaxKind
 
-        LabeledStatement = 191,
+        LabeledStatement = 194,
 >LabeledStatement : SyntaxKind
 
-        ThrowStatement = 192,
+        ThrowStatement = 195,
 >ThrowStatement : SyntaxKind
 
-        TryStatement = 193,
+        TryStatement = 196,
 >TryStatement : SyntaxKind
 
-        DebuggerStatement = 194,
+        DebuggerStatement = 197,
 >DebuggerStatement : SyntaxKind
 
-        VariableDeclaration = 195,
+        VariableDeclaration = 198,
 >VariableDeclaration : SyntaxKind
 
-        VariableDeclarationList = 196,
+        VariableDeclarationList = 199,
 >VariableDeclarationList : SyntaxKind
 
-        FunctionDeclaration = 197,
+        FunctionDeclaration = 200,
 >FunctionDeclaration : SyntaxKind
 
-        ClassDeclaration = 198,
+        ClassDeclaration = 201,
 >ClassDeclaration : SyntaxKind
 
-        InterfaceDeclaration = 199,
+        InterfaceDeclaration = 202,
 >InterfaceDeclaration : SyntaxKind
 
-        TypeAliasDeclaration = 200,
+        TypeAliasDeclaration = 203,
 >TypeAliasDeclaration : SyntaxKind
 
-        EnumDeclaration = 201,
+        EnumDeclaration = 204,
 >EnumDeclaration : SyntaxKind
 
-        ModuleDeclaration = 202,
+        ModuleDeclaration = 205,
 >ModuleDeclaration : SyntaxKind
 
-        ModuleBlock = 203,
+        ModuleBlock = 206,
 >ModuleBlock : SyntaxKind
 
-        CaseBlock = 204,
+        CaseBlock = 207,
 >CaseBlock : SyntaxKind
 
-        ImportEqualsDeclaration = 205,
+        ImportEqualsDeclaration = 208,
 >ImportEqualsDeclaration : SyntaxKind
 
-        ImportDeclaration = 206,
+        ImportDeclaration = 209,
 >ImportDeclaration : SyntaxKind
 
-        ImportClause = 207,
+        ImportClause = 210,
 >ImportClause : SyntaxKind
 
-        NamespaceImport = 208,
+        NamespaceImport = 211,
 >NamespaceImport : SyntaxKind
 
-        NamedImports = 209,
+        NamedImports = 212,
 >NamedImports : SyntaxKind
 
-        ImportSpecifier = 210,
+        ImportSpecifier = 213,
 >ImportSpecifier : SyntaxKind
 
-        ExportAssignment = 211,
+        ExportAssignment = 214,
 >ExportAssignment : SyntaxKind
 
-        ExportDeclaration = 212,
+        ExportDeclaration = 215,
 >ExportDeclaration : SyntaxKind
 
-        NamedExports = 213,
+        NamedExports = 216,
 >NamedExports : SyntaxKind
 
-        ExportSpecifier = 214,
+        ExportSpecifier = 217,
 >ExportSpecifier : SyntaxKind
 
-        MissingDeclaration = 215,
+        MissingDeclaration = 218,
 >MissingDeclaration : SyntaxKind
 
-        ExternalModuleReference = 216,
+        ExternalModuleReference = 219,
 >ExternalModuleReference : SyntaxKind
 
-        CaseClause = 217,
+        CaseClause = 220,
 >CaseClause : SyntaxKind
 
-        DefaultClause = 218,
+        DefaultClause = 221,
 >DefaultClause : SyntaxKind
 
-        HeritageClause = 219,
+        HeritageClause = 222,
 >HeritageClause : SyntaxKind
 
-        CatchClause = 220,
+        CatchClause = 223,
 >CatchClause : SyntaxKind
 
-        PropertyAssignment = 221,
+        PropertyAssignment = 224,
 >PropertyAssignment : SyntaxKind
 
-        ShorthandPropertyAssignment = 222,
+        ShorthandPropertyAssignment = 225,
 >ShorthandPropertyAssignment : SyntaxKind
 
-        EnumMember = 223,
+        EnumMember = 226,
 >EnumMember : SyntaxKind
 
-        SourceFile = 224,
+        SourceFile = 227,
 >SourceFile : SyntaxKind
 
-        SyntaxList = 225,
+        SyntaxList = 228,
 >SyntaxList : SyntaxKind
 
-        Count = 226,
+        Count = 229,
 >Count : SyntaxKind
 
         FirstAssignment = 53,
@@ -1526,6 +1535,13 @@ declare module "typescript" {
         body?: Block;
 >body : Block
 >Block : Block
+    }
+    interface SemicolonClassElement extends ClassElement {
+>SemicolonClassElement : SemicolonClassElement
+>ClassElement : ClassElement
+
+        _semicolonClassElementBrand: any;
+>_semicolonClassElementBrand : any
     }
     interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
 >AccessorDeclaration : AccessorDeclaration
@@ -1927,6 +1943,19 @@ declare module "typescript" {
 >arguments : NodeArray<Expression>
 >NodeArray : NodeArray<T>
 >Expression : Expression
+    }
+    interface HeritageClauseElement extends Node {
+>HeritageClauseElement : HeritageClauseElement
+>Node : Node
+
+        expression: LeftHandSideExpression;
+>expression : LeftHandSideExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        typeArguments?: NodeArray<TypeNode>;
+>typeArguments : NodeArray<TypeNode>
+>NodeArray : NodeArray<T>
+>TypeNode : TypeNode
     }
     interface NewExpression extends CallExpression, PrimaryExpression {
 >NewExpression : NewExpression
@@ -2211,10 +2240,9 @@ declare module "typescript" {
         _moduleElementBrand: any;
 >_moduleElementBrand : any
     }
-    interface ClassDeclaration extends Declaration, ModuleElement {
->ClassDeclaration : ClassDeclaration
+    interface ClassLikeDeclaration extends Declaration {
+>ClassLikeDeclaration : ClassLikeDeclaration
 >Declaration : Declaration
->ModuleElement : ModuleElement
 
         name?: Identifier;
 >name : Identifier
@@ -2234,6 +2262,16 @@ declare module "typescript" {
 >members : NodeArray<ClassElement>
 >NodeArray : NodeArray<T>
 >ClassElement : ClassElement
+    }
+    interface ClassDeclaration extends ClassLikeDeclaration, Statement {
+>ClassDeclaration : ClassDeclaration
+>ClassLikeDeclaration : ClassLikeDeclaration
+>Statement : Statement
+    }
+    interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
+>ClassExpression : ClassExpression
+>ClassLikeDeclaration : ClassLikeDeclaration
+>PrimaryExpression : PrimaryExpression
     }
     interface ClassElement extends Declaration {
 >ClassElement : ClassElement
@@ -2274,10 +2312,10 @@ declare module "typescript" {
 >token : SyntaxKind
 >SyntaxKind : SyntaxKind
 
-        types?: NodeArray<TypeReferenceNode>;
->types : NodeArray<TypeReferenceNode>
+        types?: NodeArray<HeritageClauseElement>;
+>types : NodeArray<HeritageClauseElement>
 >NodeArray : NodeArray<T>
->TypeReferenceNode : TypeReferenceNode
+>HeritageClauseElement : HeritageClauseElement
     }
     interface TypeAliasDeclaration extends Declaration, ModuleElement {
 >TypeAliasDeclaration : TypeAliasDeclaration
@@ -3220,10 +3258,11 @@ declare module "typescript" {
 >SymbolFlags : SymbolFlags
 >SymbolAccessiblityResult : SymbolAccessiblityResult
 
-        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
->isEntityNameVisible : (entityName: Identifier | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
->entityName : Identifier | QualifiedName
+        isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
+>isEntityNameVisible : (entityName: Identifier | Expression | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
+>entityName : Identifier | Expression | QualifiedName
 >EntityName : Identifier | QualifiedName
+>Expression : Expression
 >enclosingDeclaration : Node
 >Node : Node
 >SymbolVisibilityResult : SymbolVisibilityResult
@@ -3996,9 +4035,6 @@ declare module "typescript" {
         charset?: string;
 >charset : string
 
-        codepage?: number;
->codepage : number
-
         declaration?: boolean;
 >declaration : boolean
 
@@ -4039,9 +4075,6 @@ declare module "typescript" {
         noLib?: boolean;
 >noLib : boolean
 
-        noLibCheck?: boolean;
->noLibCheck : boolean
-
         noResolve?: boolean;
 >noResolve : boolean
 
@@ -4079,6 +4112,9 @@ declare module "typescript" {
         watch?: boolean;
 >watch : boolean
 
+        separateCompilation?: boolean;
+>separateCompilation : boolean
+
         [option: string]: string | number | boolean;
 >option : string
     }
@@ -4897,6 +4933,27 @@ declare module "typescript" {
 >CompilerHost : CompilerHost
 >Program : Program
 }
+declare module "typescript" {
+    /**
+      * Read tsconfig.json file
+      * @param fileName The path to the config file
+      */
+    function readConfigFile(fileName: string): any;
+>readConfigFile : (fileName: string) => any
+>fileName : string
+
+    /**
+      * Parse the contents of a config file (tsconfig.json).
+      * @param json The contents of the config file to parse
+      * @param basePath A root directory to resolve relative path entries in the config
+      *    file to. e.g. outDir
+      */
+    function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
+>parseConfigFile : (json: any, basePath?: string) => ParsedCommandLine
+>json : any
+>basePath : string
+>ParsedCommandLine : ParsedCommandLine
+}
 declare module "typescript" {
     /** The version of the language service API */
     let servicesVersion: string;
@@ -6255,6 +6312,15 @@ declare module "typescript" {
         throwIfCancellationRequested(): void;
 >throwIfCancellationRequested : () => void
     }
+    function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
+>transpile : (input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]) => string
+>input : string
+>compilerOptions : CompilerOptions
+>CompilerOptions : CompilerOptions
+>fileName : string
+>diagnostics : Diagnostic[]
+>Diagnostic : Diagnostic
+
     function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
 >createLanguageServiceSourceFile : (fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean) => SourceFile
 >fileName : string

tests/baselines/reference/APISample_watcher.js

@@ -302,59 +302,62 @@ declare module "typescript" {
         TemplateExpression = 171,
         YieldExpression = 172,
         SpreadElementExpression = 173,
-        OmittedExpression = 174,
-        TemplateSpan = 175,
-        Block = 176,
-        VariableStatement = 177,
-        EmptyStatement = 178,
-        ExpressionStatement = 179,
-        IfStatement = 180,
-        DoStatement = 181,
-        WhileStatement = 182,
-        ForStatement = 183,
-        ForInStatement = 184,
-        ForOfStatement = 185,
-        ContinueStatement = 186,
-        BreakStatement = 187,
-        ReturnStatement = 188,
-        WithStatement = 189,
-        SwitchStatement = 190,
-        LabeledStatement = 191,
-        ThrowStatement = 192,
-        TryStatement = 193,
-        DebuggerStatement = 194,
-        VariableDeclaration = 195,
-        VariableDeclarationList = 196,
-        FunctionDeclaration = 197,
-        ClassDeclaration = 198,
-        InterfaceDeclaration = 199,
-        TypeAliasDeclaration = 200,
-        EnumDeclaration = 201,
-        ModuleDeclaration = 202,
-        ModuleBlock = 203,
-        CaseBlock = 204,
-        ImportEqualsDeclaration = 205,
-        ImportDeclaration = 206,
-        ImportClause = 207,
-        NamespaceImport = 208,
-        NamedImports = 209,
-        ImportSpecifier = 210,
-        ExportAssignment = 211,
-        ExportDeclaration = 212,
-        NamedExports = 213,
-        ExportSpecifier = 214,
-        MissingDeclaration = 215,
-        ExternalModuleReference = 216,
-        CaseClause = 217,
-        DefaultClause = 218,
-        HeritageClause = 219,
-        CatchClause = 220,
-        PropertyAssignment = 221,
-        ShorthandPropertyAssignment = 222,
-        EnumMember = 223,
-        SourceFile = 224,
-        SyntaxList = 225,
-        Count = 226,
+        ClassExpression = 174,
+        OmittedExpression = 175,
+        TemplateSpan = 176,
+        HeritageClauseElement = 177,
+        SemicolonClassElement = 178,
+        Block = 179,
+        VariableStatement = 180,
+        EmptyStatement = 181,
+        ExpressionStatement = 182,
+        IfStatement = 183,
+        DoStatement = 184,
+        WhileStatement = 185,
+        ForStatement = 186,
+        ForInStatement = 187,
+        ForOfStatement = 188,
+        ContinueStatement = 189,
+        BreakStatement = 190,
+        ReturnStatement = 191,
+        WithStatement = 192,
+        SwitchStatement = 193,
+        LabeledStatement = 194,
+        ThrowStatement = 195,
+        TryStatement = 196,
+        DebuggerStatement = 197,
+        VariableDeclaration = 198,
+        VariableDeclarationList = 199,
+        FunctionDeclaration = 200,
+        ClassDeclaration = 201,
+        InterfaceDeclaration = 202,
+        TypeAliasDeclaration = 203,
+        EnumDeclaration = 204,
+        ModuleDeclaration = 205,
+        ModuleBlock = 206,
+        CaseBlock = 207,
+        ImportEqualsDeclaration = 208,
+        ImportDeclaration = 209,
+        ImportClause = 210,
+        NamespaceImport = 211,
+        NamedImports = 212,
+        ImportSpecifier = 213,
+        ExportAssignment = 214,
+        ExportDeclaration = 215,
+        NamedExports = 216,
+        ExportSpecifier = 217,
+        MissingDeclaration = 218,
+        ExternalModuleReference = 219,
+        CaseClause = 220,
+        DefaultClause = 221,
+        HeritageClause = 222,
+        CatchClause = 223,
+        PropertyAssignment = 224,
+        ShorthandPropertyAssignment = 225,
+        EnumMember = 226,
+        SourceFile = 227,
+        SyntaxList = 228,
+        Count = 229,
         FirstAssignment = 53,
         LastAssignment = 64,
         FirstReservedWord = 66,
@@ -538,6 +541,9 @@ declare module "typescript" {
     interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {
         body?: Block;
     }
+    interface SemicolonClassElement extends ClassElement {
+        _semicolonClassElementBrand: any;
+    }
     interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
         _accessorDeclarationBrand: any;
         body: Block;
@@ -676,6 +682,10 @@ declare module "typescript" {
         typeArguments?: NodeArray<TypeNode>;
         arguments: NodeArray<Expression>;
     }
+    interface HeritageClauseElement extends Node {
+        expression: LeftHandSideExpression;
+        typeArguments?: NodeArray<TypeNode>;
+    }
     interface NewExpression extends CallExpression, PrimaryExpression {
     }
     interface TaggedTemplateExpression extends MemberExpression {
@@ -770,12 +780,16 @@ declare module "typescript" {
     interface ModuleElement extends Node {
         _moduleElementBrand: any;
     }
-    interface ClassDeclaration extends Declaration, ModuleElement {
+    interface ClassLikeDeclaration extends Declaration {
         name?: Identifier;
         typeParameters?: NodeArray<TypeParameterDeclaration>;
         heritageClauses?: NodeArray<HeritageClause>;
         members: NodeArray<ClassElement>;
     }
+    interface ClassDeclaration extends ClassLikeDeclaration, Statement {
+    }
+    interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
+    }
     interface ClassElement extends Declaration {
         _classElementBrand: any;
     }
@@ -787,7 +801,7 @@ declare module "typescript" {
     }
     interface HeritageClause extends Node {
         token: SyntaxKind;
-        types?: NodeArray<TypeReferenceNode>;
+        types?: NodeArray<HeritageClauseElement>;
     }
     interface TypeAliasDeclaration extends Declaration, ModuleElement {
         name: Identifier;
@@ -1029,7 +1043,7 @@ declare module "typescript" {
         writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
-        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
+        isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
         resolvesToSomeValue(location: Node, name: string): boolean;
         getBlockScopedVariableId(node: Identifier): number;
@@ -1285,7 +1299,6 @@ declare module "typescript" {
     interface CompilerOptions {
         allowNonTsExtensions?: boolean;
         charset?: string;
-        codepage?: number;
         declaration?: boolean;
         diagnostics?: boolean;
         emitBOM?: boolean;
@@ -1299,7 +1312,6 @@ declare module "typescript" {
         noErrorTruncation?: boolean;
         noImplicitAny?: boolean;
         noLib?: boolean;
-        noLibCheck?: boolean;
         noResolve?: boolean;
         out?: string;
         outDir?: string;
@@ -1312,6 +1324,7 @@ declare module "typescript" {
         target?: ScriptTarget;
         version?: boolean;
         watch?: boolean;
+        separateCompilation?: boolean;
         [option: string]: string | number | boolean;
     }
     const enum ModuleKind {
@@ -1560,6 +1573,20 @@ declare module "typescript" {
     function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
     function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost): Program;
 }
+declare module "typescript" {
+    /**
+      * Read tsconfig.json file
+      * @param fileName The path to the config file
+      */
+    function readConfigFile(fileName: string): any;
+    /**
+      * Parse the contents of a config file (tsconfig.json).
+      * @param json The contents of the config file to parse
+      * @param basePath A root directory to resolve relative path entries in the config
+      *    file to. e.g. outDir
+      */
+    function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
+}
 declare module "typescript" {
     /** The version of the language service API */
     let servicesVersion: string;
@@ -2053,6 +2080,7 @@ declare module "typescript" {
         isCancellationRequested(): boolean;
         throwIfCancellationRequested(): void;
     }
+    function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
     function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
     let disableIncrementalParsing: boolean;
     function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
@@ -2080,33 +2108,21 @@ function watch(rootFileNames, options) {
     var files = {};
     // initialize the list of files
     rootFileNames.forEach(function (fileName) {
-        files[fileName] = {
-            version: 0
-        };
+        files[fileName] = { version: 0 };
     });
     // Create the language service host to allow the LS to communicate with the host
     var servicesHost = {
-        getScriptFileNames: function () {
-            return rootFileNames;
-        },
-        getScriptVersion: function (fileName) {
-            return files[fileName] && files[fileName].version.toString();
-        },
+        getScriptFileNames: function () { return rootFileNames; },
+        getScriptVersion: function (fileName) { return files[fileName] && files[fileName].version.toString(); },
         getScriptSnapshot: function (fileName) {
             if (!fs.existsSync(fileName)) {
                 return undefined;
             }
             return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString());
         },
-        getCurrentDirectory: function () {
-            return process.cwd();
-        },
-        getCompilationSettings: function () {
-            return options;
-        },
-        getDefaultLibFileName: function (options) {
-            return ts.getDefaultLibFilePath(options);
-        }
+        getCurrentDirectory: function () { return process.cwd(); },
+        getCompilationSettings: function () { return options; },
+        getDefaultLibFileName: function (options) { return ts.getDefaultLibFilePath(options); }
     };
     // Create the language service files
     var services = ts.createLanguageService(servicesHost, ts.createDocumentRegistry());
@@ -2115,10 +2131,7 @@ function watch(rootFileNames, options) {
         // First time around, emit all files
         emitFile(fileName);
         // Add a watch on the file to handle next change
-        fs.watchFile(fileName, {
-            persistent: true,
-            interval: 250
-        }, function (curr, prev) {
+        fs.watchFile(fileName, { persistent: true, interval: 250 }, function (curr, prev) {
             // Check timestamp
             if (+curr.mtime <= +prev.mtime) {
                 return;
@@ -2143,7 +2156,9 @@ function watch(rootFileNames, options) {
         });
     }
     function logErrors(fileName) {
-        var allDiagnostics = services.getCompilerOptionsDiagnostics().concat(services.getSyntacticDiagnostics(fileName)).concat(services.getSemanticDiagnostics(fileName));
+        var allDiagnostics = services.getCompilerOptionsDiagnostics()
+            .concat(services.getSyntacticDiagnostics(fileName))
+            .concat(services.getSemanticDiagnostics(fileName));
         allDiagnostics.forEach(function (diagnostic) {
             if (diagnostic.file) {
                 var lineChar = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
@@ -2156,10 +2171,7 @@ function watch(rootFileNames, options) {
     }
 }
 // Initialize files constituting the program as all .ts files in the current directory
-var currentDirectoryFiles = fs.readdirSync(process.cwd()).filter(function (fileName) {
-    return fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts";
-});
+var currentDirectoryFiles = fs.readdirSync(process.cwd()).
+    filter(function (fileName) { return fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts"; });
 // Start the watcher
-watch(currentDirectoryFiles, {
-    module: 1 /* CommonJS */
-});
+watch(currentDirectoryFiles, { module: 1 /* CommonJS */ });

tests/baselines/reference/APISample_watcher.types

@@ -986,163 +986,172 @@ declare module "typescript" {
         SpreadElementExpression = 173,
 >SpreadElementExpression : SyntaxKind
 
-        OmittedExpression = 174,
+        ClassExpression = 174,
+>ClassExpression : SyntaxKind
+
+        OmittedExpression = 175,
 >OmittedExpression : SyntaxKind
 
-        TemplateSpan = 175,
+        TemplateSpan = 176,
 >TemplateSpan : SyntaxKind
 
-        Block = 176,
+        HeritageClauseElement = 177,
+>HeritageClauseElement : SyntaxKind
+
+        SemicolonClassElement = 178,
+>SemicolonClassElement : SyntaxKind
+
+        Block = 179,
 >Block : SyntaxKind
 
-        VariableStatement = 177,
+        VariableStatement = 180,
 >VariableStatement : SyntaxKind
 
-        EmptyStatement = 178,
+        EmptyStatement = 181,
 >EmptyStatement : SyntaxKind
 
-        ExpressionStatement = 179,
+        ExpressionStatement = 182,
 >ExpressionStatement : SyntaxKind
 
-        IfStatement = 180,
+        IfStatement = 183,
 >IfStatement : SyntaxKind
 
-        DoStatement = 181,
+        DoStatement = 184,
 >DoStatement : SyntaxKind
 
-        WhileStatement = 182,
+        WhileStatement = 185,
 >WhileStatement : SyntaxKind
 
-        ForStatement = 183,
+        ForStatement = 186,
 >ForStatement : SyntaxKind
 
-        ForInStatement = 184,
+        ForInStatement = 187,
 >ForInStatement : SyntaxKind
 
-        ForOfStatement = 185,
+        ForOfStatement = 188,
 >ForOfStatement : SyntaxKind
 
-        ContinueStatement = 186,
+        ContinueStatement = 189,
 >ContinueStatement : SyntaxKind
 
-        BreakStatement = 187,
+        BreakStatement = 190,
 >BreakStatement : SyntaxKind
 
-        ReturnStatement = 188,
+        ReturnStatement = 191,
 >ReturnStatement : SyntaxKind
 
-        WithStatement = 189,
+        WithStatement = 192,
 >WithStatement : SyntaxKind
 
-        SwitchStatement = 190,
+        SwitchStatement = 193,
 >SwitchStatement : SyntaxKind
 
-        LabeledStatement = 191,
+        LabeledStatement = 194,
 >LabeledStatement : SyntaxKind
 
-        ThrowStatement = 192,
+        ThrowStatement = 195,
 >ThrowStatement : SyntaxKind
 
-        TryStatement = 193,
+        TryStatement = 196,
 >TryStatement : SyntaxKind
 
-        DebuggerStatement = 194,
+        DebuggerStatement = 197,
 >DebuggerStatement : SyntaxKind
 
-        VariableDeclaration = 195,
+        VariableDeclaration = 198,
 >VariableDeclaration : SyntaxKind
 
-        VariableDeclarationList = 196,
+        VariableDeclarationList = 199,
 >VariableDeclarationList : SyntaxKind
 
-        FunctionDeclaration = 197,
+        FunctionDeclaration = 200,
 >FunctionDeclaration : SyntaxKind
 
-        ClassDeclaration = 198,
+        ClassDeclaration = 201,
 >ClassDeclaration : SyntaxKind
 
-        InterfaceDeclaration = 199,
+        InterfaceDeclaration = 202,
 >InterfaceDeclaration : SyntaxKind
 
-        TypeAliasDeclaration = 200,
+        TypeAliasDeclaration = 203,
 >TypeAliasDeclaration : SyntaxKind
 
-        EnumDeclaration = 201,
+        EnumDeclaration = 204,
 >EnumDeclaration : SyntaxKind
 
-        ModuleDeclaration = 202,
+        ModuleDeclaration = 205,
 >ModuleDeclaration : SyntaxKind
 
-        ModuleBlock = 203,
+        ModuleBlock = 206,
 >ModuleBlock : SyntaxKind
 
-        CaseBlock = 204,
+        CaseBlock = 207,
 >CaseBlock : SyntaxKind
 
-        ImportEqualsDeclaration = 205,
+        ImportEqualsDeclaration = 208,
 >ImportEqualsDeclaration : SyntaxKind
 
-        ImportDeclaration = 206,
+        ImportDeclaration = 209,
 >ImportDeclaration : SyntaxKind
 
-        ImportClause = 207,
+        ImportClause = 210,
 >ImportClause : SyntaxKind
 
-        NamespaceImport = 208,
+        NamespaceImport = 211,
 >NamespaceImport : SyntaxKind
 
-        NamedImports = 209,
+        NamedImports = 212,
 >NamedImports : SyntaxKind
 
-        ImportSpecifier = 210,
+        ImportSpecifier = 213,
 >ImportSpecifier : SyntaxKind
 
-        ExportAssignment = 211,
+        ExportAssignment = 214,
 >ExportAssignment : SyntaxKind
 
-        ExportDeclaration = 212,
+        ExportDeclaration = 215,
 >ExportDeclaration : SyntaxKind
 
-        NamedExports = 213,
+        NamedExports = 216,
 >NamedExports : SyntaxKind
 
-        ExportSpecifier = 214,
+        ExportSpecifier = 217,
 >ExportSpecifier : SyntaxKind
 
-        MissingDeclaration = 215,
+        MissingDeclaration = 218,
 >MissingDeclaration : SyntaxKind
 
-        ExternalModuleReference = 216,
+        ExternalModuleReference = 219,
 >ExternalModuleReference : SyntaxKind
 
-        CaseClause = 217,
+        CaseClause = 220,
 >CaseClause : SyntaxKind
 
-        DefaultClause = 218,
+        DefaultClause = 221,
 >DefaultClause : SyntaxKind
 
-        HeritageClause = 219,
+        HeritageClause = 222,
 >HeritageClause : SyntaxKind
 
-        CatchClause = 220,
+        CatchClause = 223,
 >CatchClause : SyntaxKind
 
-        PropertyAssignment = 221,
+        PropertyAssignment = 224,
 >PropertyAssignment : SyntaxKind
 
-        ShorthandPropertyAssignment = 222,
+        ShorthandPropertyAssignment = 225,
 >ShorthandPropertyAssignment : SyntaxKind
 
-        EnumMember = 223,
+        EnumMember = 226,
 >EnumMember : SyntaxKind
 
-        SourceFile = 224,
+        SourceFile = 227,
 >SourceFile : SyntaxKind
 
-        SyntaxList = 225,
+        SyntaxList = 228,
 >SyntaxList : SyntaxKind
 
-        Count = 226,
+        Count = 229,
 >Count : SyntaxKind
 
         FirstAssignment = 53,
@@ -1699,6 +1708,13 @@ declare module "typescript" {
         body?: Block;
 >body : Block
 >Block : Block
+    }
+    interface SemicolonClassElement extends ClassElement {
+>SemicolonClassElement : SemicolonClassElement
+>ClassElement : ClassElement
+
+        _semicolonClassElementBrand: any;
+>_semicolonClassElementBrand : any
     }
     interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
 >AccessorDeclaration : AccessorDeclaration
@@ -2100,6 +2116,19 @@ declare module "typescript" {
 >arguments : NodeArray<Expression>
 >NodeArray : NodeArray<T>
 >Expression : Expression
+    }
+    interface HeritageClauseElement extends Node {
+>HeritageClauseElement : HeritageClauseElement
+>Node : Node
+
+        expression: LeftHandSideExpression;
+>expression : LeftHandSideExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        typeArguments?: NodeArray<TypeNode>;
+>typeArguments : NodeArray<TypeNode>
+>NodeArray : NodeArray<T>
+>TypeNode : TypeNode
     }
     interface NewExpression extends CallExpression, PrimaryExpression {
 >NewExpression : NewExpression
@@ -2384,10 +2413,9 @@ declare module "typescript" {
         _moduleElementBrand: any;
 >_moduleElementBrand : any
     }
-    interface ClassDeclaration extends Declaration, ModuleElement {
->ClassDeclaration : ClassDeclaration
+    interface ClassLikeDeclaration extends Declaration {
+>ClassLikeDeclaration : ClassLikeDeclaration
 >Declaration : Declaration
->ModuleElement : ModuleElement
 
         name?: Identifier;
 >name : Identifier
@@ -2407,6 +2435,16 @@ declare module "typescript" {
 >members : NodeArray<ClassElement>
 >NodeArray : NodeArray<T>
 >ClassElement : ClassElement
+    }
+    interface ClassDeclaration extends ClassLikeDeclaration, Statement {
+>ClassDeclaration : ClassDeclaration
+>ClassLikeDeclaration : ClassLikeDeclaration
+>Statement : Statement
+    }
+    interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
+>ClassExpression : ClassExpression
+>ClassLikeDeclaration : ClassLikeDeclaration
+>PrimaryExpression : PrimaryExpression
     }
     interface ClassElement extends Declaration {
 >ClassElement : ClassElement
@@ -2447,10 +2485,10 @@ declare module "typescript" {
 >token : SyntaxKind
 >SyntaxKind : SyntaxKind
 
-        types?: NodeArray<TypeReferenceNode>;
->types : NodeArray<TypeReferenceNode>
+        types?: NodeArray<HeritageClauseElement>;
+>types : NodeArray<HeritageClauseElement>
 >NodeArray : NodeArray<T>
->TypeReferenceNode : TypeReferenceNode
+>HeritageClauseElement : HeritageClauseElement
     }
     interface TypeAliasDeclaration extends Declaration, ModuleElement {
 >TypeAliasDeclaration : TypeAliasDeclaration
@@ -3393,10 +3431,11 @@ declare module "typescript" {
 >SymbolFlags : SymbolFlags
 >SymbolAccessiblityResult : SymbolAccessiblityResult
 
-        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
->isEntityNameVisible : (entityName: Identifier | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
->entityName : Identifier | QualifiedName
+        isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
+>isEntityNameVisible : (entityName: Identifier | Expression | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
+>entityName : Identifier | Expression | QualifiedName
 >EntityName : Identifier | QualifiedName
+>Expression : Expression
 >enclosingDeclaration : Node
 >Node : Node
 >SymbolVisibilityResult : SymbolVisibilityResult
@@ -4169,9 +4208,6 @@ declare module "typescript" {
         charset?: string;
 >charset : string
 
-        codepage?: number;
->codepage : number
-
         declaration?: boolean;
 >declaration : boolean
 
@@ -4212,9 +4248,6 @@ declare module "typescript" {
         noLib?: boolean;
 >noLib : boolean
 
-        noLibCheck?: boolean;
->noLibCheck : boolean
-
         noResolve?: boolean;
 >noResolve : boolean
 
@@ -4252,6 +4285,9 @@ declare module "typescript" {
         watch?: boolean;
 >watch : boolean
 
+        separateCompilation?: boolean;
+>separateCompilation : boolean
+
         [option: string]: string | number | boolean;
 >option : string
     }
@@ -5070,6 +5106,27 @@ declare module "typescript" {
 >CompilerHost : CompilerHost
 >Program : Program
 }
+declare module "typescript" {
+    /**
+      * Read tsconfig.json file
+      * @param fileName The path to the config file
+      */
+    function readConfigFile(fileName: string): any;
+>readConfigFile : (fileName: string) => any
+>fileName : string
+
+    /**
+      * Parse the contents of a config file (tsconfig.json).
+      * @param json The contents of the config file to parse
+      * @param basePath A root directory to resolve relative path entries in the config
+      *    file to. e.g. outDir
+      */
+    function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
+>parseConfigFile : (json: any, basePath?: string) => ParsedCommandLine
+>json : any
+>basePath : string
+>ParsedCommandLine : ParsedCommandLine
+}
 declare module "typescript" {
     /** The version of the language service API */
     let servicesVersion: string;
@@ -6428,6 +6485,15 @@ declare module "typescript" {
         throwIfCancellationRequested(): void;
 >throwIfCancellationRequested : () => void
     }
+    function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
+>transpile : (input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]) => string
+>input : string
+>compilerOptions : CompilerOptions
+>CompilerOptions : CompilerOptions
+>fileName : string
+>diagnostics : Diagnostic[]
+>Diagnostic : Diagnostic
+
     function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
 >createLanguageServiceSourceFile : (fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean) => SourceFile
 >fileName : string

tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.js

@@ -17,10 +17,7 @@ var cl = Point.Origin;
 
 //// [function.js]
 function Point() {
-    return {
-        x: 0,
-        y: 0
-    };
+    return { x: 0, y: 0 };
 }
 //// [test.js]
 var cl;

tests/baselines/reference/ArrowFunctionExpression1.js

@@ -2,5 +2,4 @@
 var v = (public x: string) => { };
 
 //// [ArrowFunctionExpression1.js]
-var v = function (x) {
-};
+var v = function (x) { };

tests/baselines/reference/ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.js

@@ -58,8 +58,7 @@ var clodule1 = (function () {
 })();
 var clodule1;
 (function (clodule1) {
-    function f(x) {
-    }
+    function f(x) { }
 })(clodule1 || (clodule1 = {}));
 var clodule2 = (function () {
     function clodule2() {
@@ -82,9 +81,7 @@ var clodule3 = (function () {
 })();
 var clodule3;
 (function (clodule3) {
-    clodule3.y = {
-        id: T
-    };
+    clodule3.y = { id: T };
 })(clodule3 || (clodule3 = {}));
 var clodule4 = (function () {
     function clodule4() {

tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.js

@@ -19,8 +19,7 @@ module clodule {
 var clodule = (function () {
     function clodule() {
     }
-    clodule.fn = function (id) {
-    };
+    clodule.fn = function (id) { };
     return clodule;
 })();
 var clodule;

tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.js

@@ -19,8 +19,7 @@ module clodule {
 var clodule = (function () {
     function clodule() {
     }
-    clodule.fn = function (id) {
-    };
+    clodule.fn = function (id) { };
     return clodule;
 })();
 var clodule;

tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.js

@@ -19,9 +19,7 @@ module clodule {
 var clodule = (function () {
     function clodule() {
     }
-    clodule.sfn = function (id) {
-        return 42;
-    };
+    clodule.sfn = function (id) { return 42; };
     return clodule;
 })();
 var clodule;

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.js

@@ -28,19 +28,12 @@ var Point = (function () {
         this.x = x;
         this.y = y;
     }
-    Point.Origin = function () {
-        return {
-            x: 0,
-            y: 0
-        };
-    }; // unexpected error here bug 840246
+    Point.Origin = function () { return { x: 0, y: 0 }; }; // unexpected error here bug 840246
     return Point;
 })();
 var Point;
 (function (Point) {
-    function Origin() {
-        return null;
-    }
+    function Origin() { return null; }
     Point.Origin = Origin; //expected duplicate identifier error
 })(Point || (Point = {}));
 var A;
@@ -50,20 +43,13 @@ var A;
             this.x = x;
             this.y = y;
         }
-        Point.Origin = function () {
-            return {
-                x: 0,
-                y: 0
-            };
-        }; // unexpected error here bug 840246
+        Point.Origin = function () { return { x: 0, y: 0 }; }; // unexpected error here bug 840246
         return Point;
     })();
     A.Point = Point;
     var Point;
     (function (Point) {
-        function Origin() {
-            return "";
-        }
+        function Origin() { return ""; }
         Point.Origin = Origin; //expected duplicate identifier error
     })(Point = A.Point || (A.Point = {}));
 })(A || (A = {}));

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.js

@@ -28,19 +28,12 @@ var Point = (function () {
         this.x = x;
         this.y = y;
     }
-    Point.Origin = function () {
-        return {
-            x: 0,
-            y: 0
-        };
-    };
+    Point.Origin = function () { return { x: 0, y: 0 }; };
     return Point;
 })();
 var Point;
 (function (Point) {
-    function Origin() {
-        return "";
-    } // not an error, since not exported
+    function Origin() { return ""; } // not an error, since not exported
 })(Point || (Point = {}));
 var A;
 (function (A) {
@@ -49,19 +42,12 @@ var A;
             this.x = x;
             this.y = y;
         }
-        Point.Origin = function () {
-            return {
-                x: 0,
-                y: 0
-            };
-        };
+        Point.Origin = function () { return { x: 0, y: 0 }; };
         return Point;
     })();
     A.Point = Point;
     var Point;
     (function (Point) {
-        function Origin() {
-            return "";
-        } // not an error since not exported
+        function Origin() { return ""; } // not an error since not exported
     })(Point = A.Point || (A.Point = {}));
 })(A || (A = {}));

tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.js

@@ -28,10 +28,7 @@ var Point = (function () {
         this.x = x;
         this.y = y;
     }
-    Point.Origin = {
-        x: 0,
-        y: 0
-    };
+    Point.Origin = { x: 0, y: 0 };
     return Point;
 })();
 var Point;
@@ -45,10 +42,7 @@ var A;
             this.x = x;
             this.y = y;
         }
-        Point.Origin = {
-            x: 0,
-            y: 0
-        };
+        Point.Origin = { x: 0, y: 0 };
         return Point;
     })();
     A.Point = Point;

tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.js

@@ -28,10 +28,7 @@ var Point = (function () {
         this.x = x;
         this.y = y;
     }
-    Point.Origin = {
-        x: 0,
-        y: 0
-    };
+    Point.Origin = { x: 0, y: 0 };
     return Point;
 })();
 var Point;
@@ -45,10 +42,7 @@ var A;
             this.x = x;
             this.y = y;
         }
-        Point.Origin = {
-            x: 0,
-            y: 0
-        };
+        Point.Origin = { x: 0, y: 0 };
         return Point;
     })();
     A.Point = Point;

tests/baselines/reference/ClassDeclaration11.js

@@ -8,7 +8,6 @@ class C {
 var C = (function () {
     function C() {
     }
-    C.prototype.foo = function () {
-    };
+    C.prototype.foo = function () { };
     return C;
 })();

tests/baselines/reference/ClassDeclaration13.js

@@ -8,7 +8,6 @@ class C {
 var C = (function () {
     function C() {
     }
-    C.prototype.bar = function () {
-    };
+    C.prototype.bar = function () { };
     return C;
 })();

tests/baselines/reference/ClassDeclaration21.js

@@ -8,7 +8,6 @@ class C {
 var C = (function () {
     function C() {
     }
-    C.prototype[1] = function () {
-    };
+    C.prototype[1] = function () { };
     return C;
 })();

tests/baselines/reference/ClassDeclaration22.js

@@ -8,7 +8,6 @@ class C {
 var C = (function () {
     function C() {
     }
-    C.prototype["bar"] = function () {
-    };
+    C.prototype["bar"] = function () { };
     return C;
 })();

tests/baselines/reference/ES3For-ofTypeCheck2.js

@@ -2,8 +2,6 @@
 for (var v of [true]) { }
 
 //// [ES3For-ofTypeCheck2.js]
-for (var _i = 0, _a = [
-    true
-]; _i < _a.length; _i++) {
+for (var _i = 0, _a = [true]; _i < _a.length; _i++) {
     var v = _a[_i];
 }

tests/baselines/reference/ES5For-of1.js

@@ -4,11 +4,7 @@ for (var v of ['a', 'b', 'c']) {
 }
 
 //// [ES5For-of1.js]
-for (var _i = 0, _a = [
-    'a',
-    'b',
-    'c'
-]; _i < _a.length; _i++) {
+for (var _i = 0, _a = ['a', 'b', 'c']; _i < _a.length; _i++) {
     var v = _a[_i];
     console.log(v);
 }

tests/baselines/reference/ES5For-of1.js.map

@@ -1,2 +1,2 @@
 //// [ES5For-of1.js.map]
-{"version":3,"file":"ES5For-of1.js","sourceRoot":"","sources":["ES5For-of1.ts"],"names":[],"mappings":"AAAA,GAAG,CAAC,CAAU,UAAe,EAAf;IAAC,GAAG;IAAE,GAAG;IAAE,GAAG;CAAC,EAAxB,cAAK,EAAL,IAAwB,CAAC;IAAzB,IAAI,CAAC,SAAA;IACN,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAClB"}
+{"version":3,"file":"ES5For-of1.js","sourceRoot":"","sources":["ES5For-of1.ts"],"names":[],"mappings":"AAAA,GAAG,CAAC,CAAU,UAAe,EAAf,MAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAxB,cAAK,EAAL,IAAwB,CAAC;IAAzB,IAAI,CAAC,SAAA;IACN,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAClB"}

tests/baselines/reference/ES5For-of1.sourcemap.txt

@@ -8,72 +8,61 @@ sources: ES5For-of1.ts
 emittedFile:tests/cases/conformance/statements/for-ofStatements/ES5For-of1.js
 sourceFile:ES5For-of1.ts
 -------------------------------------------------------------------
->>>for (var _i = 0, _a = [
+>>>for (var _i = 0, _a = ['a', 'b', 'c']; _i < _a.length; _i++) {
 1 >
 2 >^^^
 3 >   ^
 4 >    ^
 5 >     ^^^^^^^^^^
 6 >               ^^
+7 >                 ^^^^^^
+8 >                       ^^^
+9 >                          ^^
+10>                            ^^^
+11>                               ^^
+12>                                 ^^^
+13>                                    ^
+14>                                     ^^
+15>                                       ^^^^^^^^^^^^^^
+16>                                                     ^^
+17>                                                       ^^^^
+18>                                                           ^
 1 >
 2 >for
 3 >    
 4 >    (var v of 
 5 >     ['a', 'b', 'c']
 6 >               
+7 >                 [
+8 >                       'a'
+9 >                          , 
+10>                            'b'
+11>                               , 
+12>                                 'c'
+13>                                    ]
+14>                                     
+15>                                       var v
+16>                                                     
+17>                                                       var v of ['a', 'b', 'c']
+18>                                                           )
 1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0)
 2 >Emitted(1, 4) Source(1, 4) + SourceIndex(0)
 3 >Emitted(1, 5) Source(1, 5) + SourceIndex(0)
 4 >Emitted(1, 6) Source(1, 15) + SourceIndex(0)
 5 >Emitted(1, 16) Source(1, 30) + SourceIndex(0)
 6 >Emitted(1, 18) Source(1, 15) + SourceIndex(0)
----
->>>    'a',
-1 >^^^^
-2 >    ^^^
-3 >       ^^->
-1 >[
-2 >    'a'
-1 >Emitted(2, 5) Source(1, 16) + SourceIndex(0)
-2 >Emitted(2, 8) Source(1, 19) + SourceIndex(0)
----
->>>    'b',
-1->^^^^
-2 >    ^^^
-3 >       ^->
-1->, 
-2 >    'b'
-1->Emitted(3, 5) Source(1, 21) + SourceIndex(0)
-2 >Emitted(3, 8) Source(1, 24) + SourceIndex(0)
----
->>>    'c'
-1->^^^^
-2 >    ^^^
-3 >       ^^^^^^^^^^^^^^^^^^^^->
-1->, 
-2 >    'c'
-1->Emitted(4, 5) Source(1, 26) + SourceIndex(0)
-2 >Emitted(4, 8) Source(1, 29) + SourceIndex(0)
----
->>>]; _i < _a.length; _i++) {
-1->^
-2 > ^^
-3 >   ^^^^^^^^^^^^^^
-4 >                 ^^
-5 >                   ^^^^
-6 >                       ^
-1->]
-2 > 
-3 >   var v
-4 >                 
-5 >                   var v of ['a', 'b', 'c']
-6 >                       )
-1->Emitted(5, 2) Source(1, 30) + SourceIndex(0)
-2 >Emitted(5, 4) Source(1, 6) + SourceIndex(0)
-3 >Emitted(5, 18) Source(1, 11) + SourceIndex(0)
-4 >Emitted(5, 20) Source(1, 6) + SourceIndex(0)
-5 >Emitted(5, 24) Source(1, 30) + SourceIndex(0)
-6 >Emitted(5, 25) Source(1, 31) + SourceIndex(0)
+7 >Emitted(1, 24) Source(1, 16) + SourceIndex(0)
+8 >Emitted(1, 27) Source(1, 19) + SourceIndex(0)
+9 >Emitted(1, 29) Source(1, 21) + SourceIndex(0)
+10>Emitted(1, 32) Source(1, 24) + SourceIndex(0)
+11>Emitted(1, 34) Source(1, 26) + SourceIndex(0)
+12>Emitted(1, 37) Source(1, 29) + SourceIndex(0)
+13>Emitted(1, 38) Source(1, 30) + SourceIndex(0)
+14>Emitted(1, 40) Source(1, 6) + SourceIndex(0)
+15>Emitted(1, 54) Source(1, 11) + SourceIndex(0)
+16>Emitted(1, 56) Source(1, 6) + SourceIndex(0)
+17>Emitted(1, 60) Source(1, 30) + SourceIndex(0)
+18>Emitted(1, 61) Source(1, 31) + SourceIndex(0)
 ---
 >>>    var v = _a[_i];
 1 >^^^^
@@ -85,10 +74,10 @@ sourceFile:ES5For-of1.ts
 2 >    var 
 3 >        v
 4 >         
-1 >Emitted(6, 5) Source(1, 6) + SourceIndex(0)
-2 >Emitted(6, 9) Source(1, 10) + SourceIndex(0)
-3 >Emitted(6, 10) Source(1, 11) + SourceIndex(0)
-4 >Emitted(6, 19) Source(1, 11) + SourceIndex(0)
+1 >Emitted(2, 5) Source(1, 6) + SourceIndex(0)
+2 >Emitted(2, 9) Source(1, 10) + SourceIndex(0)
+3 >Emitted(2, 10) Source(1, 11) + SourceIndex(0)
+4 >Emitted(2, 19) Source(1, 11) + SourceIndex(0)
 ---
 >>>    console.log(v);
 1->^^^^
@@ -108,20 +97,20 @@ sourceFile:ES5For-of1.ts
 6 >                v
 7 >                 )
 8 >                  ;
-1->Emitted(7, 5) Source(2, 5) + SourceIndex(0)
-2 >Emitted(7, 12) Source(2, 12) + SourceIndex(0)
-3 >Emitted(7, 13) Source(2, 13) + SourceIndex(0)
-4 >Emitted(7, 16) Source(2, 16) + SourceIndex(0)
-5 >Emitted(7, 17) Source(2, 17) + SourceIndex(0)
-6 >Emitted(7, 18) Source(2, 18) + SourceIndex(0)
-7 >Emitted(7, 19) Source(2, 19) + SourceIndex(0)
-8 >Emitted(7, 20) Source(2, 20) + SourceIndex(0)
+1->Emitted(3, 5) Source(2, 5) + SourceIndex(0)
+2 >Emitted(3, 12) Source(2, 12) + SourceIndex(0)
+3 >Emitted(3, 13) Source(2, 13) + SourceIndex(0)
+4 >Emitted(3, 16) Source(2, 16) + SourceIndex(0)
+5 >Emitted(3, 17) Source(2, 17) + SourceIndex(0)
+6 >Emitted(3, 18) Source(2, 18) + SourceIndex(0)
+7 >Emitted(3, 19) Source(2, 19) + SourceIndex(0)
+8 >Emitted(3, 20) Source(2, 20) + SourceIndex(0)
 ---
 >>>}
 1 >^
 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
 1 >
   >}
-1 >Emitted(8, 2) Source(3, 2) + SourceIndex(0)
+1 >Emitted(4, 2) Source(3, 2) + SourceIndex(0)
 ---
 >>>//# sourceMappingURL=ES5For-of1.js.map

tests/baselines/reference/ES5For-of10.js

@@ -9,9 +9,7 @@ for (foo().x of []) {
 
 //// [ES5For-of10.js]
 function foo() {
-    return {
-        x: 0
-    };
+    return { x: 0 };
 }
 for (var _i = 0, _a = []; _i < _a.length; _i++) {
     foo().x = _a[_i];

tests/baselines/reference/ES5For-of12.js

@@ -2,10 +2,6 @@
 for ([""] of [[""]]) { }
 
 //// [ES5For-of12.js]
-for (var _i = 0, _a = [
-    [
-        ""
-    ]
-]; _i < _a.length; _i++) {
+for (var _i = 0, _a = [[""]]; _i < _a.length; _i++) {
     "" = _a[_i][0];
 }

tests/baselines/reference/ES5For-of13.js

@@ -4,11 +4,7 @@ for (let v of ['a', 'b', 'c']) {
 }
 
 //// [ES5For-of13.js]
-for (var _i = 0, _a = [
-    'a',
-    'b',
-    'c'
-]; _i < _a.length; _i++) {
+for (var _i = 0, _a = ['a', 'b', 'c']; _i < _a.length; _i++) {
     var v = _a[_i];
     var x = v;
 }

tests/baselines/reference/ES5For-of13.js.map

@@ -1,2 +1,2 @@
 //// [ES5For-of13.js.map]
-{"version":3,"file":"ES5For-of13.js","sourceRoot":"","sources":["ES5For-of13.ts"],"names":[],"mappings":"AAAA,GAAG,CAAC,CAAU,UAAe,EAAf;IAAC,GAAG;IAAE,GAAG;IAAE,GAAG;CAAC,EAAxB,cAAK,EAAL,IAAwB,CAAC;IAAzB,IAAI,CAAC,SAAA;IACN,IAAI,CAAC,GAAG,CAAC,CAAC;CACb"}
+{"version":3,"file":"ES5For-of13.js","sourceRoot":"","sources":["ES5For-of13.ts"],"names":[],"mappings":"AAAA,GAAG,CAAC,CAAU,UAAe,EAAf,MAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAxB,cAAK,EAAL,IAAwB,CAAC;IAAzB,IAAI,CAAC,SAAA;IACN,IAAI,CAAC,GAAG,CAAC,CAAC;CACb"}

tests/baselines/reference/ES5For-of13.sourcemap.txt

@@ -8,72 +8,61 @@ sources: ES5For-of13.ts
 emittedFile:tests/cases/conformance/statements/for-ofStatements/ES5For-of13.js
 sourceFile:ES5For-of13.ts
 -------------------------------------------------------------------
->>>for (var _i = 0, _a = [
+>>>for (var _i = 0, _a = ['a', 'b', 'c']; _i < _a.length; _i++) {
 1 >
 2 >^^^
 3 >   ^
 4 >    ^
 5 >     ^^^^^^^^^^
 6 >               ^^
+7 >                 ^^^^^^
+8 >                       ^^^
+9 >                          ^^
+10>                            ^^^
+11>                               ^^
+12>                                 ^^^
+13>                                    ^
+14>                                     ^^
+15>                                       ^^^^^^^^^^^^^^
+16>                                                     ^^
+17>                                                       ^^^^
+18>                                                           ^
 1 >
 2 >for
 3 >    
 4 >    (let v of 
 5 >     ['a', 'b', 'c']
 6 >               
+7 >                 [
+8 >                       'a'
+9 >                          , 
+10>                            'b'
+11>                               , 
+12>                                 'c'
+13>                                    ]
+14>                                     
+15>                                       let v
+16>                                                     
+17>                                                       let v of ['a', 'b', 'c']
+18>                                                           )
 1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0)
 2 >Emitted(1, 4) Source(1, 4) + SourceIndex(0)
 3 >Emitted(1, 5) Source(1, 5) + SourceIndex(0)
 4 >Emitted(1, 6) Source(1, 15) + SourceIndex(0)
 5 >Emitted(1, 16) Source(1, 30) + SourceIndex(0)
 6 >Emitted(1, 18) Source(1, 15) + SourceIndex(0)
----
->>>    'a',
-1 >^^^^
-2 >    ^^^
-3 >       ^^->
-1 >[
-2 >    'a'
-1 >Emitted(2, 5) Source(1, 16) + SourceIndex(0)
-2 >Emitted(2, 8) Source(1, 19) + SourceIndex(0)
----
->>>    'b',
-1->^^^^
-2 >    ^^^
-3 >       ^->
-1->, 
-2 >    'b'
-1->Emitted(3, 5) Source(1, 21) + SourceIndex(0)
-2 >Emitted(3, 8) Source(1, 24) + SourceIndex(0)
----
->>>    'c'
-1->^^^^
-2 >    ^^^
-3 >       ^^^^^^^^^^^^^^^^^^^^->
-1->, 
-2 >    'c'
-1->Emitted(4, 5) Source(1, 26) + SourceIndex(0)
-2 >Emitted(4, 8) Source(1, 29) + SourceIndex(0)
----
->>>]; _i < _a.length; _i++) {
-1->^
-2 > ^^
-3 >   ^^^^^^^^^^^^^^
-4 >                 ^^
-5 >                   ^^^^
-6 >                       ^
-1->]
-2 > 
-3 >   let v
-4 >                 
-5 >                   let v of ['a', 'b', 'c']
-6 >                       )
-1->Emitted(5, 2) Source(1, 30) + SourceIndex(0)
-2 >Emitted(5, 4) Source(1, 6) + SourceIndex(0)
-3 >Emitted(5, 18) Source(1, 11) + SourceIndex(0)
-4 >Emitted(5, 20) Source(1, 6) + SourceIndex(0)
-5 >Emitted(5, 24) Source(1, 30) + SourceIndex(0)
-6 >Emitted(5, 25) Source(1, 31) + SourceIndex(0)
+7 >Emitted(1, 24) Source(1, 16) + SourceIndex(0)
+8 >Emitted(1, 27) Source(1, 19) + SourceIndex(0)
+9 >Emitted(1, 29) Source(1, 21) + SourceIndex(0)
+10>Emitted(1, 32) Source(1, 24) + SourceIndex(0)
+11>Emitted(1, 34) Source(1, 26) + SourceIndex(0)
+12>Emitted(1, 37) Source(1, 29) + SourceIndex(0)
+13>Emitted(1, 38) Source(1, 30) + SourceIndex(0)
+14>Emitted(1, 40) Source(1, 6) + SourceIndex(0)
+15>Emitted(1, 54) Source(1, 11) + SourceIndex(0)
+16>Emitted(1, 56) Source(1, 6) + SourceIndex(0)
+17>Emitted(1, 60) Source(1, 30) + SourceIndex(0)
+18>Emitted(1, 61) Source(1, 31) + SourceIndex(0)
 ---
 >>>    var v = _a[_i];
 1 >^^^^
@@ -84,10 +73,10 @@ sourceFile:ES5For-of13.ts
 2 >    let 
 3 >        v
 4 >         
-1 >Emitted(6, 5) Source(1, 6) + SourceIndex(0)
-2 >Emitted(6, 9) Source(1, 10) + SourceIndex(0)
-3 >Emitted(6, 10) Source(1, 11) + SourceIndex(0)
-4 >Emitted(6, 19) Source(1, 11) + SourceIndex(0)
+1 >Emitted(2, 5) Source(1, 6) + SourceIndex(0)
+2 >Emitted(2, 9) Source(1, 10) + SourceIndex(0)
+3 >Emitted(2, 10) Source(1, 11) + SourceIndex(0)
+4 >Emitted(2, 19) Source(1, 11) + SourceIndex(0)
 ---
 >>>    var x = v;
 1 >^^^^
@@ -103,18 +92,18 @@ sourceFile:ES5For-of13.ts
 4 >          = 
 5 >            v
 6 >             ;
-1 >Emitted(7, 5) Source(2, 5) + SourceIndex(0)
-2 >Emitted(7, 9) Source(2, 9) + SourceIndex(0)
-3 >Emitted(7, 10) Source(2, 10) + SourceIndex(0)
-4 >Emitted(7, 13) Source(2, 13) + SourceIndex(0)
-5 >Emitted(7, 14) Source(2, 14) + SourceIndex(0)
-6 >Emitted(7, 15) Source(2, 15) + SourceIndex(0)
+1 >Emitted(3, 5) Source(2, 5) + SourceIndex(0)
+2 >Emitted(3, 9) Source(2, 9) + SourceIndex(0)
+3 >Emitted(3, 10) Source(2, 10) + SourceIndex(0)
+4 >Emitted(3, 13) Source(2, 13) + SourceIndex(0)
+5 >Emitted(3, 14) Source(2, 14) + SourceIndex(0)
+6 >Emitted(3, 15) Source(2, 15) + SourceIndex(0)
 ---
 >>>}
 1 >^
 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
 1 >
   >}
-1 >Emitted(8, 2) Source(3, 2) + SourceIndex(0)
+1 >Emitted(4, 2) Source(3, 2) + SourceIndex(0)
 ---
 >>>//# sourceMappingURL=ES5For-of13.js.map

tests/baselines/reference/ES5For-of17.js

@@ -11,9 +11,7 @@ for (let v of []) {
 for (var _i = 0, _a = []; _i < _a.length; _i++) {
     var v = _a[_i];
     v;
-    for (var _b = 0, _c = [
-        v
-    ]; _b < _c.length; _b++) {
+    for (var _b = 0, _c = [v]; _b < _c.length; _b++) {
         var v_1 = _c[_b];
         var x = v_1;
         v_1++;

tests/baselines/reference/ES5For-of20.js

@@ -10,9 +10,7 @@ for (let v of []) {
 for (var _i = 0, _a = []; _i < _a.length; _i++) {
     var v = _a[_i];
     var v_1;
-    for (var _b = 0, _c = [
-        v
-    ]; _b < _c.length; _b++) {
+    for (var _b = 0, _c = [v]; _b < _c.length; _b++) {
         var v_2 = _c[_b];
         var v_3;
     }

tests/baselines/reference/ES5For-of21.js

@@ -4,9 +4,9 @@ for (let v of []) {
 }
 
 //// [ES5For-of21.js]
-for (var _i = 0, _a = []; _i < _a.length; _i++) {
-    var v = _a[_i];
-    for (var _b = 0, _c = []; _b < _c.length; _b++) {
-        var _i_1 = _c[_b];
+for (var _a = 0, _b = []; _a < _b.length; _a++) {
+    var v = _b[_a];
+    for (var _c = 0, _d = []; _c < _d.length; _c++) {
+        var _i = _d[_c];
     }
 }

tests/baselines/reference/ES5For-of22.js

@@ -5,12 +5,8 @@ for (var x of [1, 2, 3]) {
 }
 
 //// [ES5For-of22.js]
-for (var _i = 0, _a = [
-    1,
-    2,
-    3
-]; _i < _a.length; _i++) {
-    var x = _a[_i];
-    var _a_1 = 0;
+for (var _i = 0, _b = [1, 2, 3]; _i < _b.length; _i++) {
+    var x = _b[_i];
+    var _a = 0;
     console.log(x);
 }

tests/baselines/reference/ES5For-of23.js

@@ -5,11 +5,7 @@ for (var x of [1, 2, 3]) {
 }
 
 //// [ES5For-of23.js]
-for (var _i = 0, _b = [
-    1,
-    2,
-    3
-]; _i < _b.length; _i++) {
+for (var _i = 0, _b = [1, 2, 3]; _i < _b.length; _i++) {
     var x = _b[_i];
     var _a = 0;
     console.log(x);

tests/baselines/reference/ES5For-of24.js

@@ -5,11 +5,7 @@ for (var v of a) {
 }
 
 //// [ES5For-of24.js]
-var a = [
-    1,
-    2,
-    3
-];
+var a = [1, 2, 3];
 for (var _i = 0; _i < a.length; _i++) {
     var v = a[_i];
     var a_1 = 0;

tests/baselines/reference/ES5For-of25.js

@@ -6,11 +6,7 @@ for (var v of a) {
 }
 
 //// [ES5For-of25.js]
-var a = [
-    1,
-    2,
-    3
-];
+var a = [1, 2, 3];
 for (var _i = 0; _i < a.length; _i++) {
     var v = a[_i];
     v;

tests/baselines/reference/ES5For-of25.js.map

@@ -1,2 +1,2 @@
 //// [ES5For-of25.js.map]
-{"version":3,"file":"ES5For-of25.js","sourceRoot":"","sources":["ES5For-of25.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG;IAAC,CAAC;IAAE,CAAC;IAAE,CAAC;CAAC,CAAC;AAClB,GAAG,CAAC,CAAU,UAAC,EAAV,aAAK,EAAL,IAAU,CAAC;IAAX,IAAI,CAAC,GAAI,CAAC,IAAL;IACN,CAAC,CAAC;IACF,CAAC,CAAC;CACL"}
+{"version":3,"file":"ES5For-of25.js","sourceRoot":"","sources":["ES5For-of25.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAClB,GAAG,CAAC,CAAU,UAAC,EAAV,aAAK,EAAL,IAAU,CAAC;IAAX,IAAI,CAAC,GAAI,CAAC,IAAL;IACN,CAAC,CAAC;IACF,CAAC,CAAC;CACL"}

tests/baselines/reference/ES5For-of25.sourcemap.txt

@@ -8,54 +8,44 @@ sources: ES5For-of25.ts
 emittedFile:tests/cases/conformance/statements/for-ofStatements/ES5For-of25.js
 sourceFile:ES5For-of25.ts
 -------------------------------------------------------------------
->>>var a = [
+>>>var a = [1, 2, 3];
 1 >
 2 >^^^^
 3 >    ^
 4 >     ^^^
+5 >        ^
+6 >         ^
+7 >          ^^
+8 >            ^
+9 >             ^^
+10>               ^
+11>                ^
+12>                 ^
+13>                  ^^^^^^^^^^^^^^^^^^^^^^->
 1 >
 2 >var 
 3 >    a
 4 >      = 
+5 >        [
+6 >         1
+7 >          , 
+8 >            2
+9 >             , 
+10>               3
+11>                ]
+12>                 ;
 1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0)
 2 >Emitted(1, 5) Source(1, 5) + SourceIndex(0)
 3 >Emitted(1, 6) Source(1, 6) + SourceIndex(0)
 4 >Emitted(1, 9) Source(1, 9) + SourceIndex(0)
----
->>>    1,
-1 >^^^^
-2 >    ^
-3 >     ^^->
-1 >[
-2 >    1
-1 >Emitted(2, 5) Source(1, 10) + SourceIndex(0)
-2 >Emitted(2, 6) Source(1, 11) + SourceIndex(0)
----
->>>    2,
-1->^^^^
-2 >    ^
-3 >     ^->
-1->, 
-2 >    2
-1->Emitted(3, 5) Source(1, 13) + SourceIndex(0)
-2 >Emitted(3, 6) Source(1, 14) + SourceIndex(0)
----
->>>    3
-1->^^^^
-2 >    ^
-1->, 
-2 >    3
-1->Emitted(4, 5) Source(1, 16) + SourceIndex(0)
-2 >Emitted(4, 6) Source(1, 17) + SourceIndex(0)
----
->>>];
-1 >^
-2 > ^
-3 >  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
-1 >]
-2 > ;
-1 >Emitted(5, 2) Source(1, 18) + SourceIndex(0)
-2 >Emitted(5, 3) Source(1, 19) + SourceIndex(0)
+5 >Emitted(1, 10) Source(1, 10) + SourceIndex(0)
+6 >Emitted(1, 11) Source(1, 11) + SourceIndex(0)
+7 >Emitted(1, 13) Source(1, 13) + SourceIndex(0)
+8 >Emitted(1, 14) Source(1, 14) + SourceIndex(0)
+9 >Emitted(1, 16) Source(1, 16) + SourceIndex(0)
+10>Emitted(1, 17) Source(1, 17) + SourceIndex(0)
+11>Emitted(1, 18) Source(1, 18) + SourceIndex(0)
+12>Emitted(1, 19) Source(1, 19) + SourceIndex(0)
 ---
 >>>for (var _i = 0; _i < a.length; _i++) {
 1->
@@ -79,16 +69,16 @@ sourceFile:ES5For-of25.ts
 8 >                              
 9 >                                var v of a
 10>                                    )
-1->Emitted(6, 1) Source(2, 1) + SourceIndex(0)
-2 >Emitted(6, 4) Source(2, 4) + SourceIndex(0)
-3 >Emitted(6, 5) Source(2, 5) + SourceIndex(0)
-4 >Emitted(6, 6) Source(2, 15) + SourceIndex(0)
-5 >Emitted(6, 16) Source(2, 16) + SourceIndex(0)
-6 >Emitted(6, 18) Source(2, 6) + SourceIndex(0)
-7 >Emitted(6, 31) Source(2, 11) + SourceIndex(0)
-8 >Emitted(6, 33) Source(2, 6) + SourceIndex(0)
-9 >Emitted(6, 37) Source(2, 16) + SourceIndex(0)
-10>Emitted(6, 38) Source(2, 17) + SourceIndex(0)
+1->Emitted(2, 1) Source(2, 1) + SourceIndex(0)
+2 >Emitted(2, 4) Source(2, 4) + SourceIndex(0)
+3 >Emitted(2, 5) Source(2, 5) + SourceIndex(0)
+4 >Emitted(2, 6) Source(2, 15) + SourceIndex(0)
+5 >Emitted(2, 16) Source(2, 16) + SourceIndex(0)
+6 >Emitted(2, 18) Source(2, 6) + SourceIndex(0)
+7 >Emitted(2, 31) Source(2, 11) + SourceIndex(0)
+8 >Emitted(2, 33) Source(2, 6) + SourceIndex(0)
+9 >Emitted(2, 37) Source(2, 16) + SourceIndex(0)
+10>Emitted(2, 38) Source(2, 17) + SourceIndex(0)
 ---
 >>>    var v = a[_i];
 1 >^^^^
@@ -103,12 +93,12 @@ sourceFile:ES5For-of25.ts
 4 >          of 
 5 >            a
 6 >             
-1 >Emitted(7, 5) Source(2, 6) + SourceIndex(0)
-2 >Emitted(7, 9) Source(2, 10) + SourceIndex(0)
-3 >Emitted(7, 10) Source(2, 11) + SourceIndex(0)
-4 >Emitted(7, 13) Source(2, 15) + SourceIndex(0)
-5 >Emitted(7, 14) Source(2, 16) + SourceIndex(0)
-6 >Emitted(7, 18) Source(2, 11) + SourceIndex(0)
+1 >Emitted(3, 5) Source(2, 6) + SourceIndex(0)
+2 >Emitted(3, 9) Source(2, 10) + SourceIndex(0)
+3 >Emitted(3, 10) Source(2, 11) + SourceIndex(0)
+4 >Emitted(3, 13) Source(2, 15) + SourceIndex(0)
+5 >Emitted(3, 14) Source(2, 16) + SourceIndex(0)
+6 >Emitted(3, 18) Source(2, 11) + SourceIndex(0)
 ---
 >>>    v;
 1 >^^^^
@@ -119,9 +109,9 @@ sourceFile:ES5For-of25.ts
   >    
 2 >    v
 3 >     ;
-1 >Emitted(8, 5) Source(3, 5) + SourceIndex(0)
-2 >Emitted(8, 6) Source(3, 6) + SourceIndex(0)
-3 >Emitted(8, 7) Source(3, 7) + SourceIndex(0)
+1 >Emitted(4, 5) Source(3, 5) + SourceIndex(0)
+2 >Emitted(4, 6) Source(3, 6) + SourceIndex(0)
+3 >Emitted(4, 7) Source(3, 7) + SourceIndex(0)
 ---
 >>>    a;
 1->^^^^
@@ -131,15 +121,15 @@ sourceFile:ES5For-of25.ts
   >    
 2 >    a
 3 >     ;
-1->Emitted(9, 5) Source(4, 5) + SourceIndex(0)
-2 >Emitted(9, 6) Source(4, 6) + SourceIndex(0)
-3 >Emitted(9, 7) Source(4, 7) + SourceIndex(0)
+1->Emitted(5, 5) Source(4, 5) + SourceIndex(0)
+2 >Emitted(5, 6) Source(4, 6) + SourceIndex(0)
+3 >Emitted(5, 7) Source(4, 7) + SourceIndex(0)
 ---
 >>>}
 1 >^
 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
 1 >
   >}
-1 >Emitted(10, 2) Source(5, 2) + SourceIndex(0)
+1 >Emitted(6, 2) Source(5, 2) + SourceIndex(0)
 ---
 >>>//# sourceMappingURL=ES5For-of25.js.map

tests/baselines/reference/ES5For-of26.js

@@ -5,10 +5,7 @@ for (var [a = 0, b = 1] of [2, 3]) {
 }
 
 //// [ES5For-of26.js]
-for (var _i = 0, _a = [
-    2,
-    3
-]; _i < _a.length; _i++) {
+for (var _i = 0, _a = [2, 3]; _i < _a.length; _i++) {
     var _b = _a[_i], _c = _b[0], a = _c === void 0 ? 0 : _c, _d = _b[1], b = _d === void 0 ? 1 : _d;
     a;
     b;

tests/baselines/reference/ES5For-of26.js.map

@@ -1,2 +1,2 @@
 //// [ES5For-of26.js.map]
-{"version":3,"file":"ES5For-of26.js","sourceRoot":"","sources":["ES5For-of26.ts"],"names":[],"mappings":"AAAA,GAAG,CAAC,CAAuB,UAAM,EAAN;IAAC,CAAC;IAAE,CAAC;CAAC,EAA5B,cAAkB,EAAlB,IAA4B,CAAC;IAA7B,6BAAK,CAAC,mBAAG,CAAC,mBAAE,CAAC,mBAAG,CAAC,KAAC;IACnB,CAAC,CAAC;IACF,CAAC,CAAC;CACL"}
+{"version":3,"file":"ES5For-of26.js","sourceRoot":"","sources":["ES5For-of26.ts"],"names":[],"mappings":"AAAA,GAAG,CAAC,CAAuB,UAAM,EAAN,MAAC,CAAC,EAAE,CAAC,CAAC,EAA5B,cAAkB,EAAlB,IAA4B,CAAC;IAA7B,6BAAK,CAAC,mBAAG,CAAC,mBAAE,CAAC,mBAAG,CAAC,KAAC;IACnB,CAAC,CAAC;IACF,CAAC,CAAC;CACL"}

tests/baselines/reference/ES5For-of26.sourcemap.txt

@@ -8,64 +8,56 @@ sources: ES5For-of26.ts
 emittedFile:tests/cases/conformance/statements/for-ofStatements/ES5For-of26.js
 sourceFile:ES5For-of26.ts
 -------------------------------------------------------------------
->>>for (var _i = 0, _a = [
+>>>for (var _i = 0, _a = [2, 3]; _i < _a.length; _i++) {
 1 >
 2 >^^^
 3 >   ^
 4 >    ^
 5 >     ^^^^^^^^^^
 6 >               ^^
+7 >                 ^^^^^^
+8 >                       ^
+9 >                        ^^
+10>                          ^
+11>                           ^
+12>                            ^^
+13>                              ^^^^^^^^^^^^^^
+14>                                            ^^
+15>                                              ^^^^
+16>                                                  ^
+17>                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
 1 >
 2 >for
 3 >    
 4 >    (var [a = 0, b = 1] of 
 5 >     [2, 3]
 6 >               
+7 >                 [
+8 >                       2
+9 >                        , 
+10>                          3
+11>                           ]
+12>                            
+13>                              var [a = 0, b = 1]
+14>                                            
+15>                                              var [a = 0, b = 1] of [2, 3]
+16>                                                  )
 1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0)
 2 >Emitted(1, 4) Source(1, 4) + SourceIndex(0)
 3 >Emitted(1, 5) Source(1, 5) + SourceIndex(0)
 4 >Emitted(1, 6) Source(1, 28) + SourceIndex(0)
 5 >Emitted(1, 16) Source(1, 34) + SourceIndex(0)
 6 >Emitted(1, 18) Source(1, 28) + SourceIndex(0)
----
->>>    2,
-1 >^^^^
-2 >    ^
-3 >     ^->
-1 >[
-2 >    2
-1 >Emitted(2, 5) Source(1, 29) + SourceIndex(0)
-2 >Emitted(2, 6) Source(1, 30) + SourceIndex(0)
----
->>>    3
-1->^^^^
-2 >    ^
-3 >     ^^^^^^^^^^^^^^^^^^^^^^->
-1->, 
-2 >    3
-1->Emitted(3, 5) Source(1, 32) + SourceIndex(0)
-2 >Emitted(3, 6) Source(1, 33) + SourceIndex(0)
----
->>>]; _i < _a.length; _i++) {
-1->^
-2 > ^^
-3 >   ^^^^^^^^^^^^^^
-4 >                 ^^
-5 >                   ^^^^
-6 >                       ^
-7 >                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
-1->]
-2 > 
-3 >   var [a = 0, b = 1]
-4 >                 
-5 >                   var [a = 0, b = 1] of [2, 3]
-6 >                       )
-1->Emitted(4, 2) Source(1, 34) + SourceIndex(0)
-2 >Emitted(4, 4) Source(1, 6) + SourceIndex(0)
-3 >Emitted(4, 18) Source(1, 24) + SourceIndex(0)
-4 >Emitted(4, 20) Source(1, 6) + SourceIndex(0)
-5 >Emitted(4, 24) Source(1, 34) + SourceIndex(0)
-6 >Emitted(4, 25) Source(1, 35) + SourceIndex(0)
+7 >Emitted(1, 24) Source(1, 29) + SourceIndex(0)
+8 >Emitted(1, 25) Source(1, 30) + SourceIndex(0)
+9 >Emitted(1, 27) Source(1, 32) + SourceIndex(0)
+10>Emitted(1, 28) Source(1, 33) + SourceIndex(0)
+11>Emitted(1, 29) Source(1, 34) + SourceIndex(0)
+12>Emitted(1, 31) Source(1, 6) + SourceIndex(0)
+13>Emitted(1, 45) Source(1, 24) + SourceIndex(0)
+14>Emitted(1, 47) Source(1, 6) + SourceIndex(0)
+15>Emitted(1, 51) Source(1, 34) + SourceIndex(0)
+16>Emitted(1, 52) Source(1, 35) + SourceIndex(0)
 ---
 >>>    var _b = _a[_i], _c = _b[0], a = _c === void 0 ? 0 : _c, _d = _b[1], b = _d === void 0 ? 1 : _d;
 1->^^^^
@@ -88,16 +80,16 @@ sourceFile:ES5For-of26.ts
 8 >                                                                           = 
 9 >                                                                                             1
 10>                                                                                              ]
-1->Emitted(5, 5) Source(1, 6) + SourceIndex(0)
-2 >Emitted(5, 34) Source(1, 11) + SourceIndex(0)
-3 >Emitted(5, 35) Source(1, 12) + SourceIndex(0)
-4 >Emitted(5, 54) Source(1, 15) + SourceIndex(0)
-5 >Emitted(5, 55) Source(1, 16) + SourceIndex(0)
-6 >Emitted(5, 74) Source(1, 18) + SourceIndex(0)
-7 >Emitted(5, 75) Source(1, 19) + SourceIndex(0)
-8 >Emitted(5, 94) Source(1, 22) + SourceIndex(0)
-9 >Emitted(5, 95) Source(1, 23) + SourceIndex(0)
-10>Emitted(5, 100) Source(1, 24) + SourceIndex(0)
+1->Emitted(2, 5) Source(1, 6) + SourceIndex(0)
+2 >Emitted(2, 34) Source(1, 11) + SourceIndex(0)
+3 >Emitted(2, 35) Source(1, 12) + SourceIndex(0)
+4 >Emitted(2, 54) Source(1, 15) + SourceIndex(0)
+5 >Emitted(2, 55) Source(1, 16) + SourceIndex(0)
+6 >Emitted(2, 74) Source(1, 18) + SourceIndex(0)
+7 >Emitted(2, 75) Source(1, 19) + SourceIndex(0)
+8 >Emitted(2, 94) Source(1, 22) + SourceIndex(0)
+9 >Emitted(2, 95) Source(1, 23) + SourceIndex(0)
+10>Emitted(2, 100) Source(1, 24) + SourceIndex(0)
 ---
 >>>    a;
 1 >^^^^
@@ -108,9 +100,9 @@ sourceFile:ES5For-of26.ts
   >    
 2 >    a
 3 >     ;
-1 >Emitted(6, 5) Source(2, 5) + SourceIndex(0)
-2 >Emitted(6, 6) Source(2, 6) + SourceIndex(0)
-3 >Emitted(6, 7) Source(2, 7) + SourceIndex(0)
+1 >Emitted(3, 5) Source(2, 5) + SourceIndex(0)
+2 >Emitted(3, 6) Source(2, 6) + SourceIndex(0)
+3 >Emitted(3, 7) Source(2, 7) + SourceIndex(0)
 ---
 >>>    b;
 1->^^^^
@@ -120,15 +112,15 @@ sourceFile:ES5For-of26.ts
   >    
 2 >    b
 3 >     ;
-1->Emitted(7, 5) Source(3, 5) + SourceIndex(0)
-2 >Emitted(7, 6) Source(3, 6) + SourceIndex(0)
-3 >Emitted(7, 7) Source(3, 7) + SourceIndex(0)
+1->Emitted(4, 5) Source(3, 5) + SourceIndex(0)
+2 >Emitted(4, 6) Source(3, 6) + SourceIndex(0)
+3 >Emitted(4, 7) Source(3, 7) + SourceIndex(0)
 ---
 >>>}
 1 >^
 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
 1 >
   >}
-1 >Emitted(8, 2) Source(4, 2) + SourceIndex(0)
+1 >Emitted(5, 2) Source(4, 2) + SourceIndex(0)
 ---
 >>>//# sourceMappingURL=ES5For-of26.js.map

tests/baselines/reference/ES5For-of27.js

@@ -5,10 +5,7 @@ for (var {x: a = 0, y: b = 1} of [2, 3]) {
 }
 
 //// [ES5For-of27.js]
-for (var _i = 0, _a = [
-    2,
-    3
-]; _i < _a.length; _i++) {
+for (var _i = 0, _a = [2, 3]; _i < _a.length; _i++) {
     var _b = _a[_i], _c = _b.x, a = _c === void 0 ? 0 : _c, _d = _b.y, b = _d === void 0 ? 1 : _d;
     a;
     b;

tests/baselines/reference/ES5For-of28.js

@@ -5,10 +5,7 @@ for (let [a = 0, b = 1] of [2, 3]) {
 }
 
 //// [ES5For-of28.js]
-for (var _i = 0, _a = [
-    2,
-    3
-]; _i < _a.length; _i++) {
+for (var _i = 0, _a = [2, 3]; _i < _a.length; _i++) {
     var _b = _a[_i], _c = _b[0], a = _c === void 0 ? 0 : _c, _d = _b[1], b = _d === void 0 ? 1 : _d;
     a;
     b;

tests/baselines/reference/ES5For-of29.js

@@ -5,10 +5,7 @@ for (const {x: a = 0, y: b = 1} of [2, 3]) {
 }
 
 //// [ES5For-of29.js]
-for (var _i = 0, _a = [
-    2,
-    3
-]; _i < _a.length; _i++) {
+for (var _i = 0, _a = [2, 3]; _i < _a.length; _i++) {
     var _b = _a[_i], _c = _b.x, a = _c === void 0 ? 0 : _c, _d = _b.y, b = _d === void 0 ? 1 : _d;
     a;
     b;

tests/baselines/reference/ES5For-of3.js

@@ -3,11 +3,7 @@ for (var v of ['a', 'b', 'c'])
     var x = v;
 
 //// [ES5For-of3.js]
-for (var _i = 0, _a = [
-    'a',
-    'b',
-    'c'
-]; _i < _a.length; _i++) {
+for (var _i = 0, _a = ['a', 'b', 'c']; _i < _a.length; _i++) {
     var v = _a[_i];
     var x = v;
 }

tests/baselines/reference/ES5For-of3.js.map

@@ -1,2 +1,2 @@
 //// [ES5For-of3.js.map]
-{"version":3,"file":"ES5For-of3.js","sourceRoot":"","sources":["ES5For-of3.ts"],"names":[],"mappings":"AAAA,GAAG,CAAC,CAAU,UAAe,EAAf;IAAC,GAAG;IAAE,GAAG;IAAE,GAAG;CAAC,EAAxB,cAAK,EAAL,IAAwB,CAAC;IAAzB,IAAI,CAAC,SAAA;IACN,IAAI,CAAC,GAAG,CAAC,CAAC;CAAA"}
+{"version":3,"file":"ES5For-of3.js","sourceRoot":"","sources":["ES5For-of3.ts"],"names":[],"mappings":"AAAA,GAAG,CAAC,CAAU,UAAe,EAAf,MAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAxB,cAAK,EAAL,IAAwB,CAAC;IAAzB,IAAI,CAAC,SAAA;IACN,IAAI,CAAC,GAAG,CAAC,CAAC;CAAA"}

tests/baselines/reference/ES5For-of3.sourcemap.txt

@@ -8,72 +8,61 @@ sources: ES5For-of3.ts
 emittedFile:tests/cases/conformance/statements/for-ofStatements/ES5For-of3.js
 sourceFile:ES5For-of3.ts
 -------------------------------------------------------------------
->>>for (var _i = 0, _a = [
+>>>for (var _i = 0, _a = ['a', 'b', 'c']; _i < _a.length; _i++) {
 1 >
 2 >^^^
 3 >   ^
 4 >    ^
 5 >     ^^^^^^^^^^
 6 >               ^^
+7 >                 ^^^^^^
+8 >                       ^^^
+9 >                          ^^
+10>                            ^^^
+11>                               ^^
+12>                                 ^^^
+13>                                    ^
+14>                                     ^^
+15>                                       ^^^^^^^^^^^^^^
+16>                                                     ^^
+17>                                                       ^^^^
+18>                                                           ^
 1 >
 2 >for
 3 >    
 4 >    (var v of 
 5 >     ['a', 'b', 'c']
 6 >               
+7 >                 [
+8 >                       'a'
+9 >                          , 
+10>                            'b'
+11>                               , 
+12>                                 'c'
+13>                                    ]
+14>                                     
+15>                                       var v
+16>                                                     
+17>                                                       var v of ['a', 'b', 'c']
+18>                                                           )
 1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0)
 2 >Emitted(1, 4) Source(1, 4) + SourceIndex(0)
 3 >Emitted(1, 5) Source(1, 5) + SourceIndex(0)
 4 >Emitted(1, 6) Source(1, 15) + SourceIndex(0)
 5 >Emitted(1, 16) Source(1, 30) + SourceIndex(0)
 6 >Emitted(1, 18) Source(1, 15) + SourceIndex(0)
----
->>>    'a',
-1 >^^^^
-2 >    ^^^
-3 >       ^^->
-1 >[
-2 >    'a'
-1 >Emitted(2, 5) Source(1, 16) + SourceIndex(0)
-2 >Emitted(2, 8) Source(1, 19) + SourceIndex(0)
----
->>>    'b',
-1->^^^^
-2 >    ^^^
-3 >       ^->
-1->, 
-2 >    'b'
-1->Emitted(3, 5) Source(1, 21) + SourceIndex(0)
-2 >Emitted(3, 8) Source(1, 24) + SourceIndex(0)
----
->>>    'c'
-1->^^^^
-2 >    ^^^
-3 >       ^^^^^^^^^^^^^^^^^^^^->
-1->, 
-2 >    'c'
-1->Emitted(4, 5) Source(1, 26) + SourceIndex(0)
-2 >Emitted(4, 8) Source(1, 29) + SourceIndex(0)
----
->>>]; _i < _a.length; _i++) {
-1->^
-2 > ^^
-3 >   ^^^^^^^^^^^^^^
-4 >                 ^^
-5 >                   ^^^^
-6 >                       ^
-1->]
-2 > 
-3 >   var v
-4 >                 
-5 >                   var v of ['a', 'b', 'c']
-6 >                       )
-1->Emitted(5, 2) Source(1, 30) + SourceIndex(0)
-2 >Emitted(5, 4) Source(1, 6) + SourceIndex(0)
-3 >Emitted(5, 18) Source(1, 11) + SourceIndex(0)
-4 >Emitted(5, 20) Source(1, 6) + SourceIndex(0)
-5 >Emitted(5, 24) Source(1, 30) + SourceIndex(0)
-6 >Emitted(5, 25) Source(1, 31) + SourceIndex(0)
+7 >Emitted(1, 24) Source(1, 16) + SourceIndex(0)
+8 >Emitted(1, 27) Source(1, 19) + SourceIndex(0)
+9 >Emitted(1, 29) Source(1, 21) + SourceIndex(0)
+10>Emitted(1, 32) Source(1, 24) + SourceIndex(0)
+11>Emitted(1, 34) Source(1, 26) + SourceIndex(0)
+12>Emitted(1, 37) Source(1, 29) + SourceIndex(0)
+13>Emitted(1, 38) Source(1, 30) + SourceIndex(0)
+14>Emitted(1, 40) Source(1, 6) + SourceIndex(0)
+15>Emitted(1, 54) Source(1, 11) + SourceIndex(0)
+16>Emitted(1, 56) Source(1, 6) + SourceIndex(0)
+17>Emitted(1, 60) Source(1, 30) + SourceIndex(0)
+18>Emitted(1, 61) Source(1, 31) + SourceIndex(0)
 ---
 >>>    var v = _a[_i];
 1 >^^^^
@@ -84,10 +73,10 @@ sourceFile:ES5For-of3.ts
 2 >    var 
 3 >        v
 4 >         
-1 >Emitted(6, 5) Source(1, 6) + SourceIndex(0)
-2 >Emitted(6, 9) Source(1, 10) + SourceIndex(0)
-3 >Emitted(6, 10) Source(1, 11) + SourceIndex(0)
-4 >Emitted(6, 19) Source(1, 11) + SourceIndex(0)
+1 >Emitted(2, 5) Source(1, 6) + SourceIndex(0)
+2 >Emitted(2, 9) Source(1, 10) + SourceIndex(0)
+3 >Emitted(2, 10) Source(1, 11) + SourceIndex(0)
+4 >Emitted(2, 19) Source(1, 11) + SourceIndex(0)
 ---
 >>>    var x = v;
 1 >^^^^
@@ -103,17 +92,17 @@ sourceFile:ES5For-of3.ts
 4 >          = 
 5 >            v
 6 >             ;
-1 >Emitted(7, 5) Source(2, 5) + SourceIndex(0)
-2 >Emitted(7, 9) Source(2, 9) + SourceIndex(0)
-3 >Emitted(7, 10) Source(2, 10) + SourceIndex(0)
-4 >Emitted(7, 13) Source(2, 13) + SourceIndex(0)
-5 >Emitted(7, 14) Source(2, 14) + SourceIndex(0)
-6 >Emitted(7, 15) Source(2, 15) + SourceIndex(0)
+1 >Emitted(3, 5) Source(2, 5) + SourceIndex(0)
+2 >Emitted(3, 9) Source(2, 9) + SourceIndex(0)
+3 >Emitted(3, 10) Source(2, 10) + SourceIndex(0)
+4 >Emitted(3, 13) Source(2, 13) + SourceIndex(0)
+5 >Emitted(3, 14) Source(2, 14) + SourceIndex(0)
+6 >Emitted(3, 15) Source(2, 15) + SourceIndex(0)
 ---
 >>>}
 1 >^
 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
 1 >
-1 >Emitted(8, 2) Source(2, 15) + SourceIndex(0)
+1 >Emitted(4, 2) Source(2, 15) + SourceIndex(0)
 ---
 >>>//# sourceMappingURL=ES5For-of3.js.map

tests/baselines/reference/ES5For-of30.js

@@ -8,10 +8,7 @@ for ([a = 1, b = ""] of tuple) {
 
 //// [ES5For-of30.js]
 var a, b;
-var tuple = [
-    2,
-    "3"
-];
+var tuple = [2, "3"];
 for (var _i = 0; _i < tuple.length; _i++) {
     _a = tuple[_i], _b = _a[0], a = _b === void 0 ? 1 : _b, _c = _a[1], b = _c === void 0 ? "" : _c;
     a;

tests/baselines/reference/ES5For-of6.js

@@ -10,9 +10,6 @@ for (var _i = 0, _a = []; _i < _a.length; _i++) {
     var w = _a[_i];
     for (var _b = 0, _c = []; _b < _c.length; _b++) {
         var v = _c[_b];
-        var x = [
-            w,
-            v
-        ];
+        var x = [w, v];
     }
 }

tests/baselines/reference/ES5For-of7.js

@@ -14,8 +14,5 @@ for (var _i = 0, _a = []; _i < _a.length; _i++) {
 }
 for (var _b = 0, _c = []; _b < _c.length; _b++) {
     var v = _c[_b];
-    var x = [
-        w,
-        v
-    ];
+    var x = [w, v];
 }

tests/baselines/reference/ES5For-of8.js

@@ -8,15 +8,9 @@ for (foo().x of ['a', 'b', 'c']) {
 
 //// [ES5For-of8.js]
 function foo() {
-    return {
-        x: 0
-    };
+    return { x: 0 };
 }
-for (var _i = 0, _a = [
-    'a',
-    'b',
-    'c'
-]; _i < _a.length; _i++) {
+for (var _i = 0, _a = ['a', 'b', 'c']; _i < _a.length; _i++) {
     foo().x = _a[_i];
     var p = foo().x;
 }

tests/baselines/reference/ES5For-of8.js.map

@@ -1,2 +1,2 @@
 //// [ES5For-of8.js.map]
-{"version":3,"file":"ES5For-of8.js","sourceRoot":"","sources":["ES5For-of8.ts"],"names":["foo"],"mappings":"AAAA;IACIA,MAAMA,CAACA;QAAEA,CAACA,EAAEA,CAACA;KAAEA,CAACA;AACpBA,CAACA;AACD,GAAG,CAAC,CAAY,UAAe,EAAf;IAAC,GAAG;IAAE,GAAG;IAAE,GAAG;CAAC,EAA1B,cAAO,EAAP,IAA0B,CAAC;IAA3B,GAAG,EAAE,CAAC,CAAC,SAAA;IACR,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC;CACnB"}
+{"version":3,"file":"ES5For-of8.js","sourceRoot":"","sources":["ES5For-of8.ts"],"names":["foo"],"mappings":"AAAA;IACIA,MAAMA,CAACA,EAAEA,CAACA,EAAEA,CAACA,EAAEA,CAACA;AACpBA,CAACA;AACD,GAAG,CAAC,CAAY,UAAe,EAAf,MAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAA1B,cAAO,EAAP,IAA0B,CAAC;IAA3B,GAAG,EAAE,CAAC,CAAC,SAAA;IACR,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC;CACnB"}

tests/baselines/reference/ES5For-of8.sourcemap.txt

@@ -10,62 +10,69 @@ sourceFile:ES5For-of8.ts
 -------------------------------------------------------------------
 >>>function foo() {
 1 >
-2 >^^^^^^^^^^^^^->
+2 >^^^^^^^^^^^^^^^^^^^^^->
 1 >
 1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0)
 ---
->>>    return {
+>>>    return { x: 0 };
 1->^^^^
 2 >    ^^^^^^
 3 >          ^
-4 >           ^^->
+4 >           ^^
+5 >             ^
+6 >              ^^
+7 >                ^
+8 >                 ^^
+9 >                   ^
 1->function foo() {
   >    
 2 >    return
 3 >           
+4 >           { 
+5 >             x
+6 >              : 
+7 >                0
+8 >                  }
+9 >                   ;
 1->Emitted(2, 5) Source(2, 5) + SourceIndex(0) name (foo)
 2 >Emitted(2, 11) Source(2, 11) + SourceIndex(0) name (foo)
 3 >Emitted(2, 12) Source(2, 12) + SourceIndex(0) name (foo)
----
->>>        x: 0
-1->^^^^^^^^
-2 >        ^
-3 >         ^^
-4 >           ^
-1->{ 
-2 >        x
-3 >         : 
-4 >           0
-1->Emitted(3, 9) Source(2, 14) + SourceIndex(0) name (foo)
-2 >Emitted(3, 10) Source(2, 15) + SourceIndex(0) name (foo)
-3 >Emitted(3, 12) Source(2, 17) + SourceIndex(0) name (foo)
-4 >Emitted(3, 13) Source(2, 18) + SourceIndex(0) name (foo)
----
->>>    };
-1 >^^^^^
-2 >     ^
-1 > }
-2 >     ;
-1 >Emitted(4, 6) Source(2, 20) + SourceIndex(0) name (foo)
-2 >Emitted(4, 7) Source(2, 21) + SourceIndex(0) name (foo)
+4 >Emitted(2, 14) Source(2, 14) + SourceIndex(0) name (foo)
+5 >Emitted(2, 15) Source(2, 15) + SourceIndex(0) name (foo)
+6 >Emitted(2, 17) Source(2, 17) + SourceIndex(0) name (foo)
+7 >Emitted(2, 18) Source(2, 18) + SourceIndex(0) name (foo)
+8 >Emitted(2, 20) Source(2, 20) + SourceIndex(0) name (foo)
+9 >Emitted(2, 21) Source(2, 21) + SourceIndex(0) name (foo)
 ---
 >>>}
 1 >
 2 >^
-3 > ^^^^^^^^^^^^^^^^^^^^^^^->
+3 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
 1 >
   >
 2 >}
-1 >Emitted(5, 1) Source(3, 1) + SourceIndex(0) name (foo)
-2 >Emitted(5, 2) Source(3, 2) + SourceIndex(0) name (foo)
+1 >Emitted(3, 1) Source(3, 1) + SourceIndex(0) name (foo)
+2 >Emitted(3, 2) Source(3, 2) + SourceIndex(0) name (foo)
 ---
->>>for (var _i = 0, _a = [
+>>>for (var _i = 0, _a = ['a', 'b', 'c']; _i < _a.length; _i++) {
 1->
 2 >^^^
 3 >   ^
 4 >    ^
 5 >     ^^^^^^^^^^
 6 >               ^^
+7 >                 ^^^^^^
+8 >                       ^^^
+9 >                          ^^
+10>                            ^^^
+11>                               ^^
+12>                                 ^^^
+13>                                    ^
+14>                                     ^^
+15>                                       ^^^^^^^^^^^^^^
+16>                                                     ^^
+17>                                                       ^^^^
+18>                                                           ^
 1->
   >
 2 >for
@@ -73,59 +80,36 @@ sourceFile:ES5For-of8.ts
 4 >    (foo().x of 
 5 >     ['a', 'b', 'c']
 6 >               
-1->Emitted(6, 1) Source(4, 1) + SourceIndex(0)
-2 >Emitted(6, 4) Source(4, 4) + SourceIndex(0)
-3 >Emitted(6, 5) Source(4, 5) + SourceIndex(0)
-4 >Emitted(6, 6) Source(4, 17) + SourceIndex(0)
-5 >Emitted(6, 16) Source(4, 32) + SourceIndex(0)
-6 >Emitted(6, 18) Source(4, 17) + SourceIndex(0)
----
->>>    'a',
-1 >^^^^
-2 >    ^^^
-3 >       ^^->
-1 >[
-2 >    'a'
-1 >Emitted(7, 5) Source(4, 18) + SourceIndex(0)
-2 >Emitted(7, 8) Source(4, 21) + SourceIndex(0)
----
->>>    'b',
-1->^^^^
-2 >    ^^^
-3 >       ^->
-1->, 
-2 >    'b'
-1->Emitted(8, 5) Source(4, 23) + SourceIndex(0)
-2 >Emitted(8, 8) Source(4, 26) + SourceIndex(0)
----
->>>    'c'
-1->^^^^
-2 >    ^^^
-3 >       ^^^^^^^^^^^^^^^^^^^^->
-1->, 
-2 >    'c'
-1->Emitted(9, 5) Source(4, 28) + SourceIndex(0)
-2 >Emitted(9, 8) Source(4, 31) + SourceIndex(0)
----
->>>]; _i < _a.length; _i++) {
-1->^
-2 > ^^
-3 >   ^^^^^^^^^^^^^^
-4 >                 ^^
-5 >                   ^^^^
-6 >                       ^
-1->]
-2 > 
-3 >   foo().x
-4 >                 
-5 >                   foo().x of ['a', 'b', 'c']
-6 >                       )
-1->Emitted(10, 2) Source(4, 32) + SourceIndex(0)
-2 >Emitted(10, 4) Source(4, 6) + SourceIndex(0)
-3 >Emitted(10, 18) Source(4, 13) + SourceIndex(0)
-4 >Emitted(10, 20) Source(4, 6) + SourceIndex(0)
-5 >Emitted(10, 24) Source(4, 32) + SourceIndex(0)
-6 >Emitted(10, 25) Source(4, 33) + SourceIndex(0)
+7 >                 [
+8 >                       'a'
+9 >                          , 
+10>                            'b'
+11>                               , 
+12>                                 'c'
+13>                                    ]
+14>                                     
+15>                                       foo().x
+16>                                                     
+17>                                                       foo().x of ['a', 'b', 'c']
+18>                                                           )
+1->Emitted(4, 1) Source(4, 1) + SourceIndex(0)
+2 >Emitted(4, 4) Source(4, 4) + SourceIndex(0)
+3 >Emitted(4, 5) Source(4, 5) + SourceIndex(0)
+4 >Emitted(4, 6) Source(4, 17) + SourceIndex(0)
+5 >Emitted(4, 16) Source(4, 32) + SourceIndex(0)
+6 >Emitted(4, 18) Source(4, 17) + SourceIndex(0)
+7 >Emitted(4, 24) Source(4, 18) + SourceIndex(0)
+8 >Emitted(4, 27) Source(4, 21) + SourceIndex(0)
+9 >Emitted(4, 29) Source(4, 23) + SourceIndex(0)
+10>Emitted(4, 32) Source(4, 26) + SourceIndex(0)
+11>Emitted(4, 34) Source(4, 28) + SourceIndex(0)
+12>Emitted(4, 37) Source(4, 31) + SourceIndex(0)
+13>Emitted(4, 38) Source(4, 32) + SourceIndex(0)
+14>Emitted(4, 40) Source(4, 6) + SourceIndex(0)
+15>Emitted(4, 54) Source(4, 13) + SourceIndex(0)
+16>Emitted(4, 56) Source(4, 6) + SourceIndex(0)
+17>Emitted(4, 60) Source(4, 32) + SourceIndex(0)
+18>Emitted(4, 61) Source(4, 33) + SourceIndex(0)
 ---
 >>>    foo().x = _a[_i];
 1 >^^^^
@@ -141,12 +125,12 @@ sourceFile:ES5For-of8.ts
 4 >         .
 5 >          x
 6 >           
-1 >Emitted(11, 5) Source(4, 6) + SourceIndex(0)
-2 >Emitted(11, 8) Source(4, 9) + SourceIndex(0)
-3 >Emitted(11, 10) Source(4, 11) + SourceIndex(0)
-4 >Emitted(11, 11) Source(4, 12) + SourceIndex(0)
-5 >Emitted(11, 12) Source(4, 13) + SourceIndex(0)
-6 >Emitted(11, 21) Source(4, 13) + SourceIndex(0)
+1 >Emitted(5, 5) Source(4, 6) + SourceIndex(0)
+2 >Emitted(5, 8) Source(4, 9) + SourceIndex(0)
+3 >Emitted(5, 10) Source(4, 11) + SourceIndex(0)
+4 >Emitted(5, 11) Source(4, 12) + SourceIndex(0)
+5 >Emitted(5, 12) Source(4, 13) + SourceIndex(0)
+6 >Emitted(5, 21) Source(4, 13) + SourceIndex(0)
 ---
 >>>    var p = foo().x;
 1->^^^^
@@ -168,21 +152,21 @@ sourceFile:ES5For-of8.ts
 7 >                 .
 8 >                  x
 9 >                   ;
-1->Emitted(12, 5) Source(5, 5) + SourceIndex(0)
-2 >Emitted(12, 9) Source(5, 9) + SourceIndex(0)
-3 >Emitted(12, 10) Source(5, 10) + SourceIndex(0)
-4 >Emitted(12, 13) Source(5, 13) + SourceIndex(0)
-5 >Emitted(12, 16) Source(5, 16) + SourceIndex(0)
-6 >Emitted(12, 18) Source(5, 18) + SourceIndex(0)
-7 >Emitted(12, 19) Source(5, 19) + SourceIndex(0)
-8 >Emitted(12, 20) Source(5, 20) + SourceIndex(0)
-9 >Emitted(12, 21) Source(5, 21) + SourceIndex(0)
+1->Emitted(6, 5) Source(5, 5) + SourceIndex(0)
+2 >Emitted(6, 9) Source(5, 9) + SourceIndex(0)
+3 >Emitted(6, 10) Source(5, 10) + SourceIndex(0)
+4 >Emitted(6, 13) Source(5, 13) + SourceIndex(0)
+5 >Emitted(6, 16) Source(5, 16) + SourceIndex(0)
+6 >Emitted(6, 18) Source(5, 18) + SourceIndex(0)
+7 >Emitted(6, 19) Source(5, 19) + SourceIndex(0)
+8 >Emitted(6, 20) Source(5, 20) + SourceIndex(0)
+9 >Emitted(6, 21) Source(5, 21) + SourceIndex(0)
 ---
 >>>}
 1 >^
 2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
 1 >
   >}
-1 >Emitted(13, 2) Source(6, 2) + SourceIndex(0)
+1 >Emitted(7, 2) Source(6, 2) + SourceIndex(0)
 ---
 >>>//# sourceMappingURL=ES5For-of8.js.map

tests/baselines/reference/ES5For-of9.js

@@ -10,9 +10,7 @@ for (foo().x of []) {
 
 //// [ES5For-of9.js]
 function foo() {
-    return {
-        x: 0
-    };
+    return { x: 0 };
 }
 for (var _i = 0, _a = []; _i < _a.length; _i++) {
     foo().x = _a[_i];

tests/baselines/reference/ES5For-ofTypeCheck2.js

@@ -2,8 +2,6 @@
 for (var v of [true]) { }
 
 //// [ES5For-ofTypeCheck2.js]
-for (var _i = 0, _a = [
-    true
-]; _i < _a.length; _i++) {
+for (var _i = 0, _a = [true]; _i < _a.length; _i++) {
     var v = _a[_i];
 }

tests/baselines/reference/ES5For-ofTypeCheck3.js

@@ -3,10 +3,7 @@ var tuple: [string, number] = ["", 0];
 for (var v of tuple) { }
 
 //// [ES5For-ofTypeCheck3.js]
-var tuple = [
-    "",
-    0
-];
+var tuple = ["", 0];
 for (var _i = 0; _i < tuple.length; _i++) {
     var v = tuple[_i];
 }

tests/baselines/reference/ES5SymbolProperty2.js

@@ -17,8 +17,7 @@ var M;
     var C = (function () {
         function C() {
         }
-        C.prototype[Symbol.iterator] = function () {
-        };
+        C.prototype[Symbol.iterator] = function () { };
         return C;
     })();
     M.C = C;

tests/baselines/reference/ES5SymbolProperty3.js

@@ -12,8 +12,7 @@ var Symbol;
 var C = (function () {
     function C() {
     }
-    C.prototype[Symbol.iterator] = function () {
-    };
+    C.prototype[Symbol.iterator] = function () { };
     return C;
 })();
 (new C)[Symbol.iterator];

tests/baselines/reference/ES5SymbolProperty4.js

@@ -12,8 +12,7 @@ var Symbol;
 var C = (function () {
     function C() {
     }
-    C.prototype[Symbol.iterator] = function () {
-    };
+    C.prototype[Symbol.iterator] = function () { };
     return C;
 })();
 (new C)[Symbol.iterator];