Merge branch 'master' into tscJsFiles

Jakefile.js

@@ -394,6 +394,7 @@ var servicesFile = path.join(builtLocalDirectory, "typescriptServices.js");
 var standaloneDefinitionsFile = path.join(builtLocalDirectory, "typescriptServices.d.ts");
 var nodePackageFile = path.join(builtLocalDirectory, "typescript.js");
 var nodeDefinitionsFile = path.join(builtLocalDirectory, "typescript.d.ts");
+var nodeStandaloneDefinitionsFile = path.join(builtLocalDirectory, "typescript_standalone.d.ts");
 
 compileFile(servicesFile, servicesSources,[builtLocalDirectory, copyright].concat(servicesSources),
             /*prefixes*/ [copyright],
@@ -410,11 +411,19 @@ compileFile(servicesFile, servicesSources,[builtLocalDirectory, copyright].conca
 
                 prependFile(copyright, standaloneDefinitionsFile);
 
-                // Create the node definition file by replacing 'ts' module with '"typescript"' as a module.
+                // Stanalone/web definition file using global 'ts' namespace
                 jake.cpR(standaloneDefinitionsFile, nodeDefinitionsFile, {silent: true});
                 var definitionFileContents = fs.readFileSync(nodeDefinitionsFile).toString();
-                definitionFileContents = definitionFileContents.replace(/declare (namespace|module) ts/g, 'declare module "typescript"');
-                fs.writeFileSync(nodeDefinitionsFile, definitionFileContents);
+
+                // Official node package definition file, pointed to by 'typings' in package.json
+                // Created by appending 'export = ts;' at the end of the standalone file to turn it into an external module
+                var nodeDefinitionsFileContents = definitionFileContents + "\r\nexport = ts;";
+                fs.writeFileSync(nodeDefinitionsFile, nodeDefinitionsFileContents);
+
+                // Node package definition file to be distributed without the package. Created by replacing 
+                // 'ts' namespace with '"typescript"' as a module.
+                var nodeStandaloneDefinitionsFileContents = definitionFileContents.replace(/declare (namespace|module) ts/g, 'declare module "typescript"');
+                fs.writeFileSync(nodeStandaloneDefinitionsFile, nodeStandaloneDefinitionsFileContents);
             });
 
 

lib/lib.d.ts

@@ -3928,6 +3928,7 @@ declare module Intl {
         timeZoneName?: string;
         formatMatcher?: string;
         hour12?: boolean;
+        timeZone?: string;
     }
 
     interface ResolvedDateTimeFormatOptions {
@@ -3997,18 +3998,45 @@ interface Number {
 
 interface Date {
     /**
-      * Converts a date to a string by using the current or specified locale.  
+      * Converts a date and time to a string by using the current or specified locale.  
       * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
     toLocaleString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
+    /**
+      * Converts a date to a string by using the current or specified locale.  
+      * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleDateString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
 
+    /**
+      * Converts a time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleTimeString(locale?: string[], options?: Intl.DateTimeFormatOptions): string;
+    
+    /**
+      * Converts a date and time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+    
     /**
       * Converts a date to a string by using the current or specified locale.  
       * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
-    toLocaleString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+    toLocaleDateString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+
+    /**
+      * Converts a time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleTimeString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
 }
 
 

lib/lib.dom.d.ts

@@ -104,6 +104,7 @@ declare module Intl {
         timeZoneName?: string;
         formatMatcher?: string;
         hour12?: boolean;
+        timeZone?: string;
     }
 
     interface ResolvedDateTimeFormatOptions {
@@ -173,18 +174,45 @@ interface Number {
 
 interface Date {
     /**
-      * Converts a date to a string by using the current or specified locale.  
+      * Converts a date and time to a string by using the current or specified locale.  
       * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
     toLocaleString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
+    /**
+      * Converts a date to a string by using the current or specified locale.  
+      * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleDateString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
 
+    /**
+      * Converts a time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleTimeString(locale?: string[], options?: Intl.DateTimeFormatOptions): string;
+    
+    /**
+      * Converts a date and time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+    
     /**
       * Converts a date to a string by using the current or specified locale.  
       * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
-    toLocaleString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+    toLocaleDateString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+
+    /**
+      * Converts a time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleTimeString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
 }
 
 

lib/lib.es6.d.ts

@@ -5216,6 +5216,7 @@ declare module Intl {
         timeZoneName?: string;
         formatMatcher?: string;
         hour12?: boolean;
+        timeZone?: string;
     }
 
     interface ResolvedDateTimeFormatOptions {
@@ -5285,18 +5286,45 @@ interface Number {
 
 interface Date {
     /**
-      * Converts a date to a string by using the current or specified locale.  
+      * Converts a date and time to a string by using the current or specified locale.  
       * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
     toLocaleString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
+    /**
+      * Converts a date to a string by using the current or specified locale.  
+      * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleDateString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
 
+    /**
+      * Converts a time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleTimeString(locale?: string[], options?: Intl.DateTimeFormatOptions): string;
+    
+    /**
+      * Converts a date and time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+    
     /**
       * Converts a date to a string by using the current or specified locale.  
       * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
-    toLocaleString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+    toLocaleDateString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+
+    /**
+      * Converts a time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleTimeString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
 }
 
 

lib/lib.webworker.d.ts

@@ -104,6 +104,7 @@ declare module Intl {
         timeZoneName?: string;
         formatMatcher?: string;
         hour12?: boolean;
+        timeZone?: string;
     }
 
     interface ResolvedDateTimeFormatOptions {
@@ -173,18 +174,45 @@ interface Number {
 
 interface Date {
     /**
-      * Converts a date to a string by using the current or specified locale.  
+      * Converts a date and time to a string by using the current or specified locale.  
       * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
     toLocaleString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
+    /**
+      * Converts a date to a string by using the current or specified locale.  
+      * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleDateString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
 
+    /**
+      * Converts a time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleTimeString(locale?: string[], options?: Intl.DateTimeFormatOptions): string;
+    
+    /**
+      * Converts a date and time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+    
     /**
       * Converts a date to a string by using the current or specified locale.  
       * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
-    toLocaleString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+    toLocaleDateString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+
+    /**
+      * Converts a time to a string by using the current or specified locale.  
+      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param options An object that contains one or more properties that specify comparison options.
+      */
+    toLocaleTimeString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
 }
 
 

lib/typescript.d.ts

@@ -13,7 +13,7 @@ See the Apache Version 2.0 License for specific language governing permissions
 and limitations under the License.
 ***************************************************************************** */
 
-declare module "typescript" {
+declare namespace ts {
     interface Map<T> {
         [index: string]: T;
     }
@@ -1208,9 +1208,11 @@ declare module "typescript" {
         UnionOrIntersection = 49152,
         StructuredType = 130048,
     }
+    type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
     interface Type {
         flags: TypeFlags;
         symbol?: Symbol;
+        pattern?: DestructuringPattern;
     }
     interface StringLiteralType extends Type {
         text: string;
@@ -1237,7 +1239,6 @@ declare module "typescript" {
     }
     interface TupleType extends ObjectType {
         elementTypes: Type[];
-        baseArrayType: TypeReference;
     }
     interface UnionOrIntersectionType extends Type {
         types: Type[];
@@ -1382,9 +1383,12 @@ declare module "typescript" {
     }
     interface ResolvedModule {
         resolvedFileName: string;
+        isExternalLibraryImport?: boolean;
+    }
+    interface ResolvedModuleWithFailedLookupLocations {
+        resolvedModule: ResolvedModule;
         failedLookupLocations: string[];
     }
-    type ModuleNameResolver = (moduleName: string, containingFile: string, options: CompilerOptions, host: ModuleResolutionHost) => ResolvedModule;
     interface CompilerHost extends ModuleResolutionHost {
         getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile;
         getCancellationToken?(): CancellationToken;
@@ -1394,7 +1398,7 @@ declare module "typescript" {
         getCanonicalFileName(fileName: string): string;
         useCaseSensitiveFileNames(): boolean;
         getNewLine(): string;
-        resolveModuleNames?(moduleNames: string[], containingFile: string): string[];
+        resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
     }
     interface TextSpan {
         start: number;
@@ -1405,7 +1409,7 @@ declare module "typescript" {
         newLength: number;
     }
 }
-declare module "typescript" {
+declare namespace ts {
     interface System {
         args: string[];
         newLine: string;
@@ -1429,7 +1433,7 @@ declare module "typescript" {
     }
     var sys: System;
 }
-declare module "typescript" {
+declare namespace ts {
     interface ErrorCallback {
         (message: DiagnosticMessage, length: number): void;
     }
@@ -1474,7 +1478,7 @@ declare module "typescript" {
     function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean;
     function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, languageVariant?: LanguageVariant, text?: string, onError?: ErrorCallback, start?: number, length?: number): Scanner;
 }
-declare module "typescript" {
+declare namespace ts {
     function getDefaultLibFileName(options: CompilerOptions): string;
     function textSpanEnd(span: TextSpan): number;
     function textSpanIsEmpty(span: TextSpan): boolean;
@@ -1504,33 +1508,32 @@ declare module "typescript" {
     function collapseTextChangeRangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange;
     function getTypeParameterOwner(d: Declaration): Declaration;
 }
-declare module "typescript" {
+declare namespace ts {
     function getNodeConstructor(kind: SyntaxKind): new () => Node;
     function createNode(kind: SyntaxKind): Node;
     function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T): T;
     function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes?: boolean): SourceFile;
     function updateSourceFile(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
 }
-declare module "typescript" {
+declare namespace ts {
     const version: string;
     function findConfigFile(searchPath: string): string;
     function resolveTripleslashReference(moduleName: string, containingFile: string): string;
-    function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModule;
-    function nodeModuleNameResolver(moduleName: string, containingFile: string, host: ModuleResolutionHost): ResolvedModule;
-    function baseUrlModuleNameResolver(moduleName: string, containingFile: string, baseUrl: string, host: ModuleResolutionHost): ResolvedModule;
-    function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModule;
+    function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations;
+    function nodeModuleNameResolver(moduleName: string, containingFile: string, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations;
+    function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations;
     function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost;
     function getPreEmitDiagnostics(program: Program, sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
     function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
     function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program): Program;
 }
-declare module "typescript" {
+declare namespace ts {
     function parseCommandLine(commandLine: string[], readFile?: (path: string) => string): ParsedCommandLine;
     /**
       * Read tsconfig.json file
       * @param fileName The path to the config file
       */
-    function readConfigFile(fileName: string): {
+    function readConfigFile(fileName: string, readFile: (path: string) => string): {
         config?: any;
         error?: Diagnostic;
     };
@@ -1551,7 +1554,7 @@ declare module "typescript" {
       */
     function parseConfigFile(json: any, host: ParseConfigHost, basePath: string): ParsedCommandLine;
 }
-declare module "typescript" {
+declare namespace ts {
     /** The version of the language service API */
     let servicesVersion: string;
     interface Node {
@@ -1649,7 +1652,7 @@ declare module "typescript" {
         trace?(s: string): void;
         error?(s: string): void;
         useCaseSensitiveFileNames?(): boolean;
-        resolveModuleNames?(moduleNames: string[], containingFile: string): string[];
+        resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
     }
     interface LanguageService {
         cleanupSemanticCache(): void;
@@ -2139,3 +2142,5 @@ declare module "typescript" {
       */
     function getDefaultLibFilePath(options: CompilerOptions): string;
 }
+
+export = ts;

lib/typescriptServices.d.ts

@@ -1208,9 +1208,11 @@ declare namespace ts {
         UnionOrIntersection = 49152,
         StructuredType = 130048,
     }
+    type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
     interface Type {
         flags: TypeFlags;
         symbol?: Symbol;
+        pattern?: DestructuringPattern;
     }
     interface StringLiteralType extends Type {
         text: string;
@@ -1237,7 +1239,6 @@ declare namespace ts {
     }
     interface TupleType extends ObjectType {
         elementTypes: Type[];
-        baseArrayType: TypeReference;
     }
     interface UnionOrIntersectionType extends Type {
         types: Type[];
@@ -1382,9 +1383,12 @@ declare namespace ts {
     }
     interface ResolvedModule {
         resolvedFileName: string;
+        isExternalLibraryImport?: boolean;
+    }
+    interface ResolvedModuleWithFailedLookupLocations {
+        resolvedModule: ResolvedModule;
         failedLookupLocations: string[];
     }
-    type ModuleNameResolver = (moduleName: string, containingFile: string, options: CompilerOptions, host: ModuleResolutionHost) => ResolvedModule;
     interface CompilerHost extends ModuleResolutionHost {
         getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile;
         getCancellationToken?(): CancellationToken;
@@ -1394,7 +1398,7 @@ declare namespace ts {
         getCanonicalFileName(fileName: string): string;
         useCaseSensitiveFileNames(): boolean;
         getNewLine(): string;
-        resolveModuleNames?(moduleNames: string[], containingFile: string): string[];
+        resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
     }
     interface TextSpan {
         start: number;
@@ -1515,10 +1519,9 @@ declare namespace ts {
     const version: string;
     function findConfigFile(searchPath: string): string;
     function resolveTripleslashReference(moduleName: string, containingFile: string): string;
-    function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModule;
-    function nodeModuleNameResolver(moduleName: string, containingFile: string, host: ModuleResolutionHost): ResolvedModule;
-    function baseUrlModuleNameResolver(moduleName: string, containingFile: string, baseUrl: string, host: ModuleResolutionHost): ResolvedModule;
-    function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModule;
+    function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations;
+    function nodeModuleNameResolver(moduleName: string, containingFile: string, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations;
+    function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations;
     function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost;
     function getPreEmitDiagnostics(program: Program, sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
     function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
@@ -1530,7 +1533,7 @@ declare namespace ts {
       * Read tsconfig.json file
       * @param fileName The path to the config file
       */
-    function readConfigFile(fileName: string): {
+    function readConfigFile(fileName: string, readFile: (path: string) => string): {
         config?: any;
         error?: Diagnostic;
     };
@@ -1649,7 +1652,7 @@ declare namespace ts {
         trace?(s: string): void;
         error?(s: string): void;
         useCaseSensitiveFileNames?(): boolean;
-        resolveModuleNames?(moduleNames: string[], containingFile: string): string[];
+        resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
     }
     interface LanguageService {
         cleanupSemanticCache(): void;

package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "http://typescriptlang.org/",
-    "version": "1.6.0",
+    "version": "1.7.0",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [

src/compiler/checker.ts

@@ -965,7 +965,7 @@ namespace ts {
             // Escape the name in the "require(...)" clause to ensure we find the right symbol.
             let moduleName = escapeIdentifier(moduleReferenceLiteral.text);
 
-            if (!moduleName) {
+            if (moduleName === undefined) {
                 return;
             }
             let isRelative = isExternalModuleNameRelative(moduleName);
@@ -14254,7 +14254,10 @@ namespace ts {
                 let symbols: Symbol[] = [];
                 let name = symbol.name;
                 forEach(getSymbolLinks(symbol).containingType.types, t => {
-                    symbols.push(getPropertyOfType(t, name));
+                    let symbol = getPropertyOfType(t, name);
+                    if (symbol) {
+                        symbols.push(symbol);
+                    }
                 });
                 return symbols;
             }

src/compiler/commandLineParser.ts

@@ -243,8 +243,9 @@ namespace ts {
                 "node": ModuleResolutionKind.NodeJs,
                 "classic": ModuleResolutionKind.Classic
             },
-            description: Diagnostics.Specifies_module_resolution_strategy_Colon_node_Node_or_classic_TypeScript_pre_1_6
-        }        
+            description: Diagnostics.Specifies_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6,
+            error: Diagnostics.Argument_for_moduleResolution_option_must_be_node_or_classic,
+        }
     ];
 
     /* @internal */
@@ -327,7 +328,7 @@ namespace ts {
                                     options[opt.name] = map[key];
                                 }
                                 else {
-                                    errors.push(createCompilerDiagnostic(opt.error));
+                                    errors.push(createCompilerDiagnostic((<CommandLineOptionOfCustomType>opt).error));
                                 }
                         }
                     }
@@ -440,7 +441,7 @@ namespace ts {
                                     value = optType[key];
                                 }
                                 else {
-                                    errors.push(createCompilerDiagnostic(opt.error));
+                                    errors.push(createCompilerDiagnostic((<CommandLineOptionOfCustomType>opt).error));
                                     value = 0;
                                 }
                             }

src/compiler/diagnosticInformationMap.generated.ts

@@ -431,6 +431,7 @@ namespace ts {
         Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1: { code: 2653, category: DiagnosticCategory.Error, key: "Non-abstract class expression does not implement inherited abstract member '{0}' from class '{1}'." },
         Exported_external_package_typings_file_cannot_contain_tripleslash_references_Please_contact_the_package_author_to_update_the_package_definition: { code: 2654, category: DiagnosticCategory.Error, key: "Exported external package typings file cannot contain tripleslash references. Please contact the package author to update the package definition." },
         Exported_external_package_typings_can_only_be_in_d_ts_files_Please_contact_the_package_author_to_update_the_package_definition: { code: 2655, category: DiagnosticCategory.Error, key: "Exported external package typings can only be in '.d.ts' files. Please contact the package author to update the package definition." },
+        Exported_external_package_typings_file_0_is_not_a_module_Please_contact_the_package_author_to_update_the_package_definition: { code: 2656, category: DiagnosticCategory.Error, key: "Exported external package typings file '{0}' is not a module. Please contact the package author to update the package definition." },
         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}'." },
@@ -565,13 +566,14 @@ namespace ts {
         Specifies_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: { code: 6060, category: DiagnosticCategory.Message, key: "Specifies the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)." },
         NEWLINE: { code: 6061, category: DiagnosticCategory.Message, key: "NEWLINE" },
         Argument_for_newLine_option_must_be_CRLF_or_LF: { code: 6062, category: DiagnosticCategory.Error, key: "Argument for '--newLine' option must be 'CRLF' or 'LF'." },
+        Argument_for_moduleResolution_option_must_be_node_or_classic: { code: 6063, category: DiagnosticCategory.Error, key: "Argument for '--moduleResolution' option must be 'node' or 'classic'." },
         Specify_JSX_code_generation_Colon_preserve_or_react: { code: 6080, category: DiagnosticCategory.Message, key: "Specify JSX code generation: 'preserve' or 'react'" },
         Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: DiagnosticCategory.Message, key: "Argument for '--jsx' must be 'preserve' or 'react'." },
         Enables_experimental_support_for_ES7_decorators: { code: 6065, category: DiagnosticCategory.Message, key: "Enables experimental support for ES7 decorators." },
         Enables_experimental_support_for_emitting_type_metadata_for_decorators: { code: 6066, category: DiagnosticCategory.Message, key: "Enables experimental support for emitting type metadata for decorators." },
         Option_experimentalAsyncFunctions_cannot_be_specified_when_targeting_ES5_or_lower: { code: 6067, category: DiagnosticCategory.Message, key: "Option 'experimentalAsyncFunctions' cannot be specified when targeting ES5 or lower." },
         Enables_experimental_support_for_ES7_async_functions: { code: 6068, category: DiagnosticCategory.Message, key: "Enables experimental support for ES7 async functions." },
-        Specifies_module_resolution_strategy_Colon_node_Node_or_classic_TypeScript_pre_1_6: { code: 6069, category: DiagnosticCategory.Message, key: "Specifies module resolution strategy: 'node' (Node) or 'classic' (TypeScript pre 1.6) ." },
+        Specifies_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6: { code: 6069, category: DiagnosticCategory.Message, key: "Specifies module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6)." },
         Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file: { code: 6070, category: DiagnosticCategory.Message, key: "Initializes a TypeScript project and creates a tsconfig.json file." },
         Successfully_created_a_tsconfig_json_file: { code: 6071, category: DiagnosticCategory.Message, key: "Successfully created a tsconfig.json file." },
         Suppress_excess_property_checks_for_object_literals: { code: 6072, category: DiagnosticCategory.Message, key: "Suppress excess property checks for object literals." },

src/compiler/diagnosticMessages.json

@@ -1700,11 +1700,11 @@
     "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead.": {
         "category": "Error",
         "code": 2652
-    },
+    },
     "Non-abstract class expression does not implement inherited abstract member '{0}' from class '{1}'.": {
         "category": "Error",
         "code": 2653
-    },
+    },
     "Exported external package typings file cannot contain tripleslash references. Please contact the package author to update the package definition.": {
         "category": "Error",
         "code": 2654
@@ -1712,7 +1712,11 @@
     "Exported external package typings can only be in '.d.ts' files. Please contact the package author to update the package definition.": {
         "category": "Error",
         "code": 2655
-    },
+    },
+    "Exported external package typings file '{0}' is not a module. Please contact the package author to update the package definition.": {
+        "category": "Error",
+        "code": 2656
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
@@ -2250,6 +2254,11 @@
         "category": "Error",
         "code": 6062
     },
+    "Argument for '--moduleResolution' option must be 'node' or 'classic'.": {
+        "category": "Error",
+        "code": 6063
+    },
+
     "Specify JSX code generation: 'preserve' or 'react'": {
         "category": "Message",
         "code": 6080
@@ -2274,7 +2283,7 @@
         "category": "Message",
         "code": 6068
     },
-    "Specifies module resolution strategy: 'node' (Node) or 'classic' (TypeScript pre 1.6) .": {
+    "Specifies module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6).": {
         "category": "Message",
         "code": 6069
     },

src/compiler/emitter.ts

@@ -3220,22 +3220,32 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     }
                 }
 
-                function ensureIdentifier(expr: Expression): Expression {
-                    if (expr.kind !== SyntaxKind.Identifier) {
-                        let identifier = createTempVariable(TempFlags.Auto);
-                        if (!canDefineTempVariablesInPlace) {
-                            recordTempDeclaration(identifier);
-                        }
-                        emitAssignment(identifier, expr);
-                        expr = identifier;
+                /**
+                 * Ensures that there exists a declared identifier whose value holds the given expression.
+                 * This function is useful to ensure that the expression's value can be read from in subsequent expressions.
+                 * Unless 'reuseIdentifierExpressions' is false, 'expr' will be returned if it is just an identifier.
+                 *
+                 * @param expr the expression whose value needs to be bound.
+                 * @param reuseIdentifierExpressions true if identifier expressions can simply be returned;
+                 *                                   false if it is necessary to always emit an identifier.
+                 */
+                function ensureIdentifier(expr: Expression, reuseIdentifierExpressions: boolean): Expression {
+                    if (expr.kind === SyntaxKind.Identifier && reuseIdentifierExpressions) {
+                        return expr;
                     }
-                    return expr;
+
+                    let identifier = createTempVariable(TempFlags.Auto);
+                    if (!canDefineTempVariablesInPlace) {
+                        recordTempDeclaration(identifier);
+                    }
+                    emitAssignment(identifier, expr);
+                    return identifier;
                 }
 
                 function createDefaultValueCheck(value: Expression, defaultValue: Expression): Expression {
                     // The value expression will be evaluated twice, so for anything but a simple identifier
                     // we need to generate a temporary variable
-                    value = ensureIdentifier(value);
+                    value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true);
                     // Return the expression 'value === void 0 ? defaultValue : value'
                     let equals = <BinaryExpression>createSynthesizedNode(SyntaxKind.BinaryExpression);
                     equals.left = value;
@@ -3286,7 +3296,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     if (properties.length !== 1) {
                         // For anything but a single element destructuring we need to generate a temporary
                         // to ensure value is evaluated exactly once.
-                        value = ensureIdentifier(value);
+                        value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true);
                     }
                     for (let p of properties) {
                         if (p.kind === SyntaxKind.PropertyAssignment || p.kind === SyntaxKind.ShorthandPropertyAssignment) {
@@ -3301,7 +3311,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     if (elements.length !== 1) {
                         // For anything but a single element destructuring we need to generate a temporary
                         // to ensure value is evaluated exactly once.
-                        value = ensureIdentifier(value);
+                        value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true);
                     }
                     for (let i = 0; i < elements.length; i++) {
                         let e = elements[i];
@@ -3346,7 +3356,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         if (root.parent.kind !== SyntaxKind.ParenthesizedExpression) {
                             write("(");
                         }
-                        value = ensureIdentifier(value);
+                        value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true);
                         emitDestructuringAssignment(target, value);
                         write(", ");
                         emit(value);
@@ -3356,7 +3366,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     }
                 }
 
-                function emitBindingElement(target: BindingElement, value: Expression) {
+                function emitBindingElement(target: BindingElement | VariableDeclaration, value: Expression) {
                     if (target.initializer) {
                         // Combine value and initializer
                         value = value ? createDefaultValueCheck(value, target.initializer) : target.initializer;
@@ -3366,14 +3376,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         value = createVoidZero();
                     }
                     if (isBindingPattern(target.name)) {
-                        let pattern = <BindingPattern>target.name;
-                        let elements = pattern.elements;
-                        if (elements.length !== 1) {
-                            // For anything but a single element destructuring we need to generate a temporary
-                            // to ensure value is evaluated exactly once.
-                            value = ensureIdentifier(value);
+                        const pattern = <BindingPattern>target.name;
+                        const elements = pattern.elements;
+                        const numElements = elements.length;
+
+                        if (numElements !== 1) {
+                            // For anything other than a single-element destructuring we need to generate a temporary
+                            // to ensure value is evaluated exactly once. Additionally, if we have zero elements
+                            // we need to emit *something* to ensure that in case a 'var' keyword was already emitted,
+                            // so in that case, we'll intentionally create that temporary.
+                            value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ numElements !== 0);
                         }
-                        for (let i = 0; i < elements.length; i++) {
+
+                        for (let i = 0; i < numElements; i++) {
                             let element = elements[i];
                             if (pattern.kind === SyntaxKind.ObjectBindingPattern) {
                                 // Rewrite element to a declaration with an initializer that fetches property
@@ -3385,7 +3400,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                                     // Rewrite element to a declaration that accesses array element at index i
                                     emitBindingElement(element, createElementAccessExpression(value, createNumericLiteral(i)));
                                 }
-                                else if (i === elements.length - 1) {
+                                else if (i === numElements - 1) {
                                     emitBindingElement(element, createSliceCall(value, i));
                                 }
                             }

src/compiler/program.ts

@@ -12,7 +12,7 @@ namespace ts {
     
     let emptyArray: any[] = [];
     
-    export const version = "1.6.0";
+    export const version = "1.7.0";
 
     export function findConfigFile(searchPath: string, moduleResolutionHost: ModuleResolutionHost): string {
         let fileName = "tsconfig.json";
@@ -1028,8 +1028,8 @@ namespace ts {
                         const importedFile = findModuleSourceFile(resolution.resolvedFileName, file.imports[i]);
                         if (importedFile && resolution.isExternalLibraryImport) {
                             if (!isExternalModule(importedFile)) {
-                                let start = getTokenPosOfNode(file.imports[i], file)
-                                fileProcessingDiagnostics.add(createFileDiagnostic(file, start, file.imports[i].end - start, Diagnostics.File_0_is_not_a_module, importedFile.fileName));
+                                let start = getTokenPosOfNode(file.imports[i], file)
+                                fileProcessingDiagnostics.add(createFileDiagnostic(file, start, file.imports[i].end - start, Diagnostics.Exported_external_package_typings_file_0_is_not_a_module_Please_contact_the_package_author_to_update_the_package_definition, importedFile.fileName));
                             }
                             else if (!fileExtensionIs(importedFile.fileName, ".d.ts")) {
                                 let start = getTokenPosOfNode(file.imports[i], file)

src/compiler/types.ts

@@ -2116,17 +2116,30 @@ namespace ts {
     }
 
     /* @internal */
-    export interface CommandLineOption {
+    export interface CommandLineOptionBase {
         name: string;
         type: string | Map<number>;         // "string", "number", "boolean", or an object literal mapping named values to actual values
         isFilePath?: boolean;               // True if option value is a path or fileName
         shortName?: string;                 // A short mnemonic for convenience - for instance, 'h' can be used in place of 'help'
         description?: DiagnosticMessage;    // The message describing what the command line switch does
         paramType?: DiagnosticMessage;      // The name to be used for a non-boolean option's parameter
-        error?: DiagnosticMessage;          // The error given when the argument does not fit a customized 'type'
         experimental?: boolean;
     }
 
+    /* @internal */
+    export interface CommandLineOptionOfPrimitiveType extends CommandLineOptionBase {
+        type: string;                   // "string" | "number" | "boolean"
+    }
+
+    /* @internal */
+    export interface CommandLineOptionOfCustomType extends CommandLineOptionBase {
+        type: Map<number>;             // an object literal mapping named values to actual values
+        error: DiagnosticMessage;      // The error given when the argument does not fit a customized 'type'
+    }
+
+    /* @internal */
+    export type CommandLineOption = CommandLineOptionOfCustomType | CommandLineOptionOfPrimitiveType;
+
     /* @internal */
     export const enum CharacterCodes {
         nullCharacter = 0,

src/harness/compilerRunner.ts

@@ -44,10 +44,10 @@ class CompilerBaselineRunner extends RunnerBase {
             // Everything declared here should be cleared out in the "after" callback.
             let justName: string;
             let content: string;
-            let testCaseContent: { settings: Harness.TestCaseParser.CompilerSetting[]; testUnitData: Harness.TestCaseParser.TestUnitData[]; };
+            let testCaseContent: { settings: Harness.TestCaseParser.CompilerSettings; testUnitData: Harness.TestCaseParser.TestUnitData[]; };
 
             let units: Harness.TestCaseParser.TestUnitData[];
-            let tcSettings: Harness.TestCaseParser.CompilerSetting[];
+            let tcSettings: Harness.TestCaseParser.CompilerSettings;
 
             let lastUnit: Harness.TestCaseParser.TestUnitData;
             let rootDir: string;
@@ -61,15 +61,12 @@ class CompilerBaselineRunner extends RunnerBase {
             let otherFiles: { unitName: string; content: string }[];
             let harnessCompiler: Harness.Compiler.HarnessCompiler;
 
-            let createNewInstance = false;
-
             before(() => {
                 justName = fileName.replace(/^.*[\\\/]/, ""); // strips the fileName from the path.
                 content = Harness.IO.readFile(fileName);
                 testCaseContent = Harness.TestCaseParser.makeUnitsFromTest(content, fileName);
                 units = testCaseContent.testUnitData;
                 tcSettings = testCaseContent.settings;
-                createNewInstance = false;
                 lastUnit = units[units.length - 1];
                 rootDir = lastUnit.originalFilePath.indexOf("conformance") === -1 ? "tests/cases/compiler/" : lastUnit.originalFilePath.substring(0, lastUnit.originalFilePath.lastIndexOf("/")) + "/";
                 harnessCompiler = Harness.Compiler.getCompiler();
@@ -100,27 +97,6 @@ class CompilerBaselineRunner extends RunnerBase {
                     });
             });
 
-            beforeEach(() => {
-                /* The compiler doesn't handle certain flags flipping during a single compilation setting. Tests on these flags will need
-                   a fresh compiler instance for themselves and then create a fresh one for the next test. Would be nice to get dev fixes
-                   eventually to remove this limitation. */
-                for (let i = 0; i < tcSettings.length; ++i) {
-                    // noImplicitAny is passed to getCompiler, but target is just passed in the settings blob to setCompilerSettings
-                    if (!createNewInstance && (tcSettings[i].flag == "noimplicitany" || tcSettings[i].flag === "target")) {
-                        harnessCompiler = Harness.Compiler.getCompiler();
-                        harnessCompiler.setCompilerSettings(tcSettings);
-                        createNewInstance = true;
-                    }
-                }
-            });
-
-            afterEach(() => {
-                if (createNewInstance) {
-                    harnessCompiler = Harness.Compiler.getCompiler();
-                    createNewInstance = false;
-                }
-            });
-
             after(() => {
                 // Mocha holds onto the closure environment of the describe callback even after the test is done.
                 // Therefore we have to clean out large objects after the test is done.
@@ -402,10 +378,6 @@ class CompilerBaselineRunner extends RunnerBase {
             else {
                 this.tests.forEach(test => this.checkTestCodeOutput(test));
             }
-
-            describe("Cleanup after compiler baselines", () => {
-                let harnessCompiler = Harness.Compiler.getCompiler();
-            });
         });
     }
 

src/harness/fourslash.ts

@@ -29,13 +29,13 @@ module FourSlash {
         fileName: string;
         version: number;
         // File-specific options (name/value pairs)
-        fileOptions: { [index: string]: string; };
+        fileOptions: Harness.TestCaseParser.CompilerSettings;
     }
 
     // Represents a set of parsed source files and options
     export interface FourSlashData {
         // Global options (name/value pairs)
-        globalOptions: { [index: string]: string; };
+        globalOptions: Harness.TestCaseParser.CompilerSettings;
 
         files: FourSlashFile[];
 
@@ -117,89 +117,17 @@ module FourSlash {
     // Add cases into convertGlobalOptionsToCompilationsSettings function for the compiler to acknowledge such option from meta data
     let metadataOptionNames = {
         baselineFile: "BaselineFile",
-        declaration: "declaration",
         emitThisFile: "emitThisFile",  // This flag is used for testing getEmitOutput feature. It allows test-cases to indicate what file to be output in multiple files project
         fileName: "Filename",
-        mapRoot: "mapRoot",
-        module: "module",
-        out: "out",
-        outFile: "outFile",
-        outDir: "outDir",
-        sourceMap: "sourceMap",
-        sourceRoot: "sourceRoot",
-        allowNonTsExtensions: "allowNonTsExtensions",
         resolveReference: "ResolveReference",  // This flag is used to specify entry file for resolve file references. The flag is only allow once per test file
-        jsx: "jsx",
     };
 
     // List of allowed metadata names
     let fileMetadataNames = [metadataOptionNames.fileName, metadataOptionNames.emitThisFile, metadataOptionNames.resolveReference];
-    let globalMetadataNames = [metadataOptionNames.allowNonTsExtensions, metadataOptionNames.baselineFile, metadataOptionNames.declaration,
-        metadataOptionNames.mapRoot, metadataOptionNames.module, metadataOptionNames.out,metadataOptionNames.outFile,
-        metadataOptionNames.outDir, metadataOptionNames.sourceMap, metadataOptionNames.sourceRoot, metadataOptionNames.jsx];
 
-    function convertGlobalOptionsToCompilerOptions(globalOptions: { [idx: string]: string }): ts.CompilerOptions {
+    function convertGlobalOptionsToCompilerOptions(globalOptions: Harness.TestCaseParser.CompilerSettings): ts.CompilerOptions {
         let settings: ts.CompilerOptions = { target: ts.ScriptTarget.ES5 };
-        // Convert all property in globalOptions into ts.CompilationSettings
-        for (let prop in globalOptions) {
-            if (globalOptions.hasOwnProperty(prop)) {
-                switch (prop) {
-                    case metadataOptionNames.allowNonTsExtensions:
-                        settings.allowNonTsExtensions = globalOptions[prop] === "true";
-                        break;
-                    case metadataOptionNames.declaration:
-                        settings.declaration = globalOptions[prop] === "true";
-                        break;
-                    case metadataOptionNames.mapRoot:
-                        settings.mapRoot = globalOptions[prop];
-                        break;
-                    case metadataOptionNames.module:
-                        // create appropriate external module target for CompilationSettings
-                        switch (globalOptions[prop]) {
-                            case "AMD":
-                                settings.module = ts.ModuleKind.AMD;
-                                break;
-                            case "CommonJS":
-                                settings.module = ts.ModuleKind.CommonJS;
-                                break;
-                            default:
-                                ts.Debug.assert(globalOptions[prop] === undefined || globalOptions[prop] === "None");
-                                settings.module = ts.ModuleKind.None;
-                                break;
-                        }
-                        break;
-                    case metadataOptionNames.out:
-                        settings.out = globalOptions[prop];
-                        break;
-                    case metadataOptionNames.outFile:
-                        settings.outFile = globalOptions[prop];
-                        break;
-                    case metadataOptionNames.outDir:
-                        settings.outDir = globalOptions[prop];
-                        break;
-                    case metadataOptionNames.sourceMap:
-                        settings.sourceMap = globalOptions[prop] === "true";
-                        break;
-                    case metadataOptionNames.sourceRoot:
-                        settings.sourceRoot = globalOptions[prop];
-                        break;
-                    case metadataOptionNames.jsx:
-                        switch (globalOptions[prop].toLowerCase()) {
-                            case "react":
-                                settings.jsx = ts.JsxEmit.React;
-                                break;
-                            case "preserve":
-                                settings.jsx = ts.JsxEmit.Preserve;
-                                break;
-                            default:
-                                ts.Debug.assert(globalOptions[prop] === undefined || globalOptions[prop] === "None");
-                                settings.jsx = ts.JsxEmit.None;
-                                break;
-                        }
-                        break;
-                }
-            }
-        }
+        Harness.Compiler.setCompilerOptionsFromHarnessSetting(globalOptions, settings);
         return settings;
     }
 
@@ -2514,12 +2442,16 @@ module FourSlash {
                 // Comment line, check for global/file @options and record them
                 let match = optionRegex.exec(line.substr(2));
                 if (match) {
-                    let globalMetadataNamesIndex = globalMetadataNames.indexOf(match[1]);
                     let fileMetadataNamesIndex = fileMetadataNames.indexOf(match[1]);
-                    if (globalMetadataNamesIndex === -1) {
-                        if (fileMetadataNamesIndex === -1) {
-                            throw new Error(`Unrecognized metadata name "${match[1]}". Available global metadata names are: ${globalMetadataNames.join(", ")}; file metadata names are: ${fileMetadataNames.join(", ")}`);
-                        } else if (fileMetadataNamesIndex === fileMetadataNames.indexOf(metadataOptionNames.fileName)) {
+                    if (fileMetadataNamesIndex === -1) {
+                        // Check if the match is already existed in the global options
+                        if (globalOptions[match[1]] !== undefined) {
+                            throw new Error("Global Option : '" + match[1] + "' is already existed");
+                        }
+                        globalOptions[match[1]] = match[2];
+                    }
+                    else {
+                        if (fileMetadataNamesIndex === fileMetadataNames.indexOf(metadataOptionNames.fileName)) {
                             // Found an @FileName directive, if this is not the first then create a new subfile
                             if (currentFileContent) {
                                 let file = parseFileContent(currentFileContent, currentFileName, markerPositions, markers, ranges);
@@ -2540,12 +2472,6 @@ module FourSlash {
                             // Add other fileMetadata flag
                             currentFileOptions[match[1]] = match[2];
                         }
-                    } else {
-                        // Check if the match is already existed in the global options
-                        if (globalOptions[match[1]] !== undefined) {
-                            throw new Error("Global Option : '" + match[1] + "' is already existed");
-                        }
-                        globalOptions[match[1]] = match[2];
                     }
                 }
             // TODO: should be '==='?

src/harness/harness.ts

@@ -468,7 +468,7 @@ module Harness {
             export const fileExists: typeof IO.fileExists = fso.FileExists;
             export const log: typeof IO.log = global.WScript && global.WScript.StdOut.WriteLine;
             export const readDirectory: typeof IO.readDirectory = (path, extension, exclude) => ts.sys.readDirectory(path, extension, exclude);
-            
+
             export function createDirectory(path: string) {
                 if (directoryExists(path)) {
                     fso.CreateFolder(path);
@@ -739,7 +739,7 @@ module Harness {
 
             export function readDirectory(path: string, extension?: string, exclude?: string[]) {
                 return listFiles(path).filter(f => !extension || ts.fileExtensionIs(f, extension));
-            }  
+            }
         }
     }
 
@@ -861,9 +861,9 @@ module Harness {
         }
 
         export function createSourceFileAndAssertInvariants(
-                fileName: string,
-                sourceText: string,
-                languageVersion: ts.ScriptTarget) {
+            fileName: string,
+            sourceText: string,
+            languageVersion: ts.ScriptTarget) {
             // We'll only assert inletiants outside of light mode. 
             const shouldAssertInvariants = !Harness.lightMode;
             
@@ -893,13 +893,13 @@ module Harness {
         }
 
         export function createCompilerHost(
-                inputFiles: { unitName: string; content: string; }[],
-                writeFile: (fn: string, contents: string, writeByteOrderMark: boolean) => void,
-                scriptTarget: ts.ScriptTarget,
-                useCaseSensitiveFileNames: boolean,
-                // the currentDirectory is needed for rwcRunner to passed in specified current directory to compiler host
-                currentDirectory?: string,
-                newLineKind?: ts.NewLineKind): ts.CompilerHost {
+            inputFiles: { unitName: string; content: string; }[],
+            writeFile: (fn: string, contents: string, writeByteOrderMark: boolean) => void,
+            scriptTarget: ts.ScriptTarget,
+            useCaseSensitiveFileNames: boolean,
+            // the currentDirectory is needed for rwcRunner to passed in specified current directory to compiler host
+            currentDirectory?: string,
+            newLineKind?: ts.NewLineKind): ts.CompilerHost {
 
             // Local get canonical file name function, that depends on passed in parameter for useCaseSensitiveFileNames
             function getCanonicalFileName(fileName: string): string {
@@ -917,7 +917,7 @@ module Harness {
                 }
             };
             inputFiles.forEach(register);
-            
+
             function getSourceFile(fn: string, languageVersion: ts.ScriptTarget) {
                 fn = ts.normalizePath(fn);
                 if (Object.prototype.hasOwnProperty.call(filemap, getCanonicalFileName(fn))) {
@@ -959,16 +959,79 @@ module Harness {
             };
         }
 
+        interface HarnessOptions {
+            useCaseSensitiveFileNames?: boolean;
+            includeBuiltFile?: string;
+            baselineFile?: string;
+        }
+
+        // Additional options not already in ts.optionDeclarations 
+        const harnessOptionDeclarations: ts.CommandLineOption[] = [
+            { name: "allowNonTsExtensions", type: "boolean" },
+            { name: "useCaseSensitiveFileNames", type: "boolean" },
+            { name: "baselineFile", type: "string" },
+            { name: "includeBuiltFile", type: "string" },
+            { name: "fileName", type: "string" },
+            { name: "noErrorTruncation", type: "boolean" }
+        ];
+
+        let optionsIndex: ts.Map<ts.CommandLineOption>;
+        function getCommandLineOption(name: string): ts.CommandLineOption {
+            if (!optionsIndex) {
+                optionsIndex = {};
+                let optionDeclarations = harnessOptionDeclarations.concat(ts.optionDeclarations);
+                for (let option of optionDeclarations) {
+                    optionsIndex[option.name.toLowerCase()] = option;
+                }
+            }
+            return ts.lookUp(optionsIndex, name.toLowerCase());
+        }
+
+        export function setCompilerOptionsFromHarnessSetting(settings: Harness.TestCaseParser.CompilerSettings, options: ts.CompilerOptions & HarnessOptions): void {
+            for (let name in settings) {
+                if (settings.hasOwnProperty(name)) {
+                    let value = settings[name];
+                    if (value === undefined) {
+                        throw new Error(`Cannot have undefined value for compiler option '${name}'.`);
+                    }
+                    let option = getCommandLineOption(name);
+                    if (option) {
+                        switch (option.type) {
+                            case "boolean":
+                                options[option.name] = value.toLowerCase() === "true";
+                                break;
+                            case "string":
+                                options[option.name] = value;
+                                break;
+                            // If not a primitive, the possible types are specified in what is effectively a map of options.
+                            default:
+                                let map = <ts.Map<number>>option.type;
+                                let key = value.toLowerCase();
+                                if (ts.hasProperty(map, key)) {
+                                    options[option.name] = map[key];
+                                }
+                                else {
+                                    throw new Error(`Unknown value '${value}' for compiler option '${name}'.`);
+                                }
+                        }
+                    }
+                    else {
+                        throw new Error(`Unknown compiler option '${name}'.`);
+                    }
+                }
+            }
+        }
+
         export class HarnessCompiler {
             private inputFiles: { unitName: string; content: string }[] = [];
             private compileOptions: ts.CompilerOptions;
-            private settings: Harness.TestCaseParser.CompilerSetting[] = [];
+            private settings: Harness.TestCaseParser.CompilerSettings = {};
 
             private lastErrors: ts.Diagnostic[];
 
             public reset() {
                 this.inputFiles = [];
-                this.settings = [];
+                this.settings = {};
                 this.lastErrors = [];
             }
 
@@ -976,11 +1039,7 @@ module Harness {
                 return this.lastErrors;
             }
 
-            public setCompilerSettingsFromOptions(tcSettings: ts.CompilerOptions) {
-                this.settings = Object.keys(tcSettings).map(k => ({ flag: k, value: (<any>tcSettings)[k] }));
-            }
-
-            public setCompilerSettings(tcSettings: Harness.TestCaseParser.CompilerSetting[]) {
+            public setCompilerSettings(tcSettings: Harness.TestCaseParser.CompilerSettings) {
                 this.settings = tcSettings;
             }
 
@@ -1016,7 +1075,7 @@ module Harness {
                 otherFiles: { unitName: string; content: string }[],
                 onComplete: (result: CompilerResult, program: ts.Program) => void,
                 settingsCallback?: (settings: ts.CompilerOptions) => void,
-                options?: ts.CompilerOptions,
+                options?: ts.CompilerOptions & HarnessOptions,
                 // Current directory is needed for rwcRunner to be able to use currentDirectory defined in json file
                 currentDirectory?: string) {
 
@@ -1025,21 +1084,27 @@ module Harness {
                 options.module = options.module || ts.ModuleKind.None;
                 options.newLine = options.newLine || ts.NewLineKind.CarriageReturnLineFeed;
                 options.noErrorTruncation = true;
+                options.skipDefaultLibCheck = true;
 
                 if (settingsCallback) {
                     settingsCallback(null);
                 }
 
                 let newLine = "\r\n";
-                options.skipDefaultLibCheck = true;
+
+                // Parse settings
+                setCompilerOptionsFromHarnessSetting(this.settings, options);
 
                 // Files from built\local that are requested by test "@includeBuiltFiles" to be in the context.
                 // Treat them as library files, so include them in build, but not in baselines.
                 let includeBuiltFiles: { unitName: string; content: string }[] = [];
+                if (options.includeBuiltFile) {
+                    let builtFileName = libFolder + options.includeBuiltFile;
+                    includeBuiltFiles.push({ unitName: builtFileName, content: normalizeLineEndings(IO.readFile(builtFileName), newLine) });
+                }
 
-                let useCaseSensitiveFileNames = Harness.IO.useCaseSensitiveFileNames();
-                this.settings.forEach(setCompilerOptionForSetting);
-
+                let useCaseSensitiveFileNames = options.useCaseSensitiveFileNames !== undefined ? options.useCaseSensitiveFileNames : Harness.IO.useCaseSensitiveFileNames();
+               
                 let fileOutputs: GeneratedFile[] = [];
 
                 let programFiles = inputFiles.concat(includeBuiltFiles).map(file => file.unitName);
@@ -1059,204 +1124,6 @@ module Harness {
                 onComplete(result, program);
 
                 return options;
-                
-                function setCompilerOptionForSetting(setting: Harness.TestCaseParser.CompilerSetting) {
-                    switch (setting.flag.toLowerCase()) {
-                        // "fileName", "comments", "declaration", "module", "nolib", "sourcemap", "target", "out", "outdir", "noimplicitany", "noresolve"
-                        case "module":
-                        case "modulegentarget":
-                            if (typeof setting.value === "string") {
-                                if (setting.value.toLowerCase() === "amd") {
-                                    options.module = ts.ModuleKind.AMD;
-                                } else if (setting.value.toLowerCase() === "umd") {
-                                    options.module = ts.ModuleKind.UMD;
-                                } else if (setting.value.toLowerCase() === "commonjs") {
-                                    options.module = ts.ModuleKind.CommonJS;
-                                    if (options.moduleResolution === undefined) {
-                                        // TODO: currently we have relative module names pretty much in all tests that use CommonJS module target.
-                                        // Such names could never be resolved in Node however classic resolution strategy still can handle them.
-                                        // Changing all module names to relative will be a major overhaul in code (but we'll do this anyway) so  as a temporary measure 
-                                        // we'll use ts.ModuleResolutionKind.Classic for CommonJS modules.
-                                        options.moduleResolution = ts.ModuleResolutionKind.Classic;
-                                    }
-                                } else if (setting.value.toLowerCase() === "system") {
-                                    options.module = ts.ModuleKind.System;
-                                } else if (setting.value.toLowerCase() === "unspecified") {
-                                    options.module = ts.ModuleKind.None;
-                                } else {
-                                    throw new Error("Unknown module type " + setting.value);
-                                }
-                            } else {
-                                options.module = <any>setting.value;
-                            }
-                            break;
-                        case "moduleresolution":
-                            switch((setting.value || "").toLowerCase()) {
-                                case "classic": 
-                                    options.moduleResolution = ts.ModuleResolutionKind.Classic;
-                                    break;
-                                case "node": 
-                                    options.moduleResolution = ts.ModuleResolutionKind.NodeJs;
-                                    break;
-                            }
-                            break;
-                        case "target":
-                        case "codegentarget":
-                            if (typeof setting.value === "string") {
-                                if (setting.value.toLowerCase() === "es3") {
-                                    options.target = ts.ScriptTarget.ES3;
-                                } else if (setting.value.toLowerCase() === "es5") {
-                                    options.target = ts.ScriptTarget.ES5;
-                                } else if (setting.value.toLowerCase() === "es6") {
-                                    options.target = ts.ScriptTarget.ES6;
-                                } else {
-                                    throw new Error("Unknown compile target " + setting.value);
-                                }
-                            } else {
-                                options.target = <any>setting.value;
-                            }
-                            break;
-                            
-                        case "experimentaldecorators":
-                            options.experimentalDecorators = setting.value === "true";
-                            break;
-
-                        case "emitdecoratormetadata":
-                            options.emitDecoratorMetadata = setting.value === "true";
-                            break;
-                            
-                        case "experimentalasyncfunctions":
-                            options.experimentalAsyncFunctions = setting.value === "true";
-                            break;
-
-                        case "noemithelpers":
-                            options.noEmitHelpers = setting.value === "true";
-                            break;
-
-                        case "noemitonerror":
-                            options.noEmitOnError = setting.value === "true";
-                            break;
-
-                        case "noresolve":
-                            options.noResolve = setting.value === "true";
-                            break;
-
-                        case "noimplicitany":
-                            options.noImplicitAny = setting.value === "true";
-                            break;
-
-                        case "nolib":
-                            options.noLib = setting.value === "true";
-                            break;
-
-                        case "out":
-                        case "outfileoption":
-                            options.out = setting.value;
-                            break;
-
-                        case "outfile":
-                            options.outFile = setting.value;
-                            break;
-
-                        case "outdiroption":
-                        case "outdir":
-                            options.outDir = setting.value;
-                            break;
-
-                        case "skipdefaultlibcheck":
-                            options.skipDefaultLibCheck = setting.value === "true";
-                            break;
-
-                        case "sourceroot":
-                            options.sourceRoot = setting.value;
-                            break;
-
-                        case "maproot":
-                            options.mapRoot = setting.value;
-                            break;
-
-                        case "sourcemap":
-                            options.sourceMap = setting.value === "true";
-                            break;
-
-                        case "declaration":
-                            options.declaration = setting.value === "true";
-                            break;
-
-                        case "newline":
-                            if (setting.value.toLowerCase() === "crlf") {
-                                options.newLine = ts.NewLineKind.CarriageReturnLineFeed;
-                            }
-                            else if (setting.value.toLowerCase() === "lf") {
-                                options.newLine = ts.NewLineKind.LineFeed;
-                            }
-                            else {
-                                throw new Error("Unknown option for newLine: " + setting.value);
-                            }
-                            break;
-
-                        case "comments":
-                            options.removeComments = setting.value === "false";
-                            break;
-
-                        case "stripinternal":
-                            options.stripInternal = setting.value === "true";
-
-                        case "usecasesensitivefilenames":
-                            useCaseSensitiveFileNames = setting.value === "true";
-                            break;
-
-                        case "filename":
-                            // Not supported yet
-                            break;
-
-                        case "emitbom":
-                            options.emitBOM = setting.value === "true";
-                            break;
-
-                        case "errortruncation":
-                            options.noErrorTruncation = setting.value === "false";
-                            break;
-
-                        case "preserveconstenums":
-                            options.preserveConstEnums = setting.value === "true";
-                            break;
-
-                        case "isolatedmodules":
-                            options.isolatedModules = setting.value === "true";
-                            break;
-
-                        case "suppressexcesspropertyerrors":
-                            options.suppressExcessPropertyErrors = setting.value === "true";
-                            break;
-
-                        case "suppressimplicitanyindexerrors":
-                            options.suppressImplicitAnyIndexErrors = setting.value === "true";
-                            break;
-
-                        case "includebuiltfile":
-                            let builtFileName = libFolder + setting.value;
-                            includeBuiltFiles.push({ unitName: builtFileName, content: normalizeLineEndings(IO.readFile(builtFileName), newLine) });
-                            break;
-
-                        case "inlinesourcemap":
-                            options.inlineSourceMap = setting.value === "true";
-                            break;
-
-                        case "inlinesources":
-                            options.inlineSources = setting.value === "true";
-                            break;
-
-                        case "jsx":
-                            options.jsx = setting.value.toLowerCase() === "react" ? ts.JsxEmit.React :
-                                          setting.value.toLowerCase() === "preserve" ? ts.JsxEmit.Preserve :
-                                          ts.JsxEmit.None;
-                            break;
-
-                        default:
-                            throw new Error("Unsupported compiler setting " + setting.flag);
-                    }
-                }
             }
 
             public compileDeclarationFiles(inputFiles: { unitName: string; content: string; }[],
@@ -1581,9 +1448,8 @@ module Harness {
 
     export module TestCaseParser {
         /** all the necessary information to set the right compiler settings */
-        export interface CompilerSetting {
-            flag: string;
-            value: string;
+        export interface CompilerSettings {
+            [name: string]: string;
         }
 
         /** All the necessary information to turn a multi file test into useful units for later compilation */
@@ -1598,30 +1464,19 @@ module Harness {
         // Regex for parsing options in the format "@Alpha: Value of any sort"
         let optionRegex = /^[\/]{2}\s*@(\w+)\s*:\s*(\S*)/gm;  // multiple matches on multiple lines
 
-        // List of allowed metadata names
-        let fileMetadataNames = ["filename", "comments", "declaration", "module",
-            "nolib", "sourcemap", "target", "out", "outdir", "noemithelpers", "noemitonerror",
-            "noimplicitany", "noresolve", "newline", "normalizenewline", "emitbom",
-            "errortruncation", "usecasesensitivefilenames", "preserveconstenums",
-            "includebuiltfile", "suppressexcesspropertyerrors", "suppressimplicitanyindexerrors", "stripinternal",
-            "isolatedmodules", "inlinesourcemap", "maproot", "sourceroot",
-            "inlinesources", "emitdecoratormetadata", "experimentaldecorators",
-            "skipdefaultlibcheck", "jsx"];
-
-        function extractCompilerSettings(content: string): CompilerSetting[] {
-
-            let opts: CompilerSetting[] = [];
+        function extractCompilerSettings(content: string): CompilerSettings {
+            let opts: CompilerSettings = {};
 
             let match: RegExpExecArray;
             while ((match = optionRegex.exec(content)) != null) {
-                opts.push({ flag: match[1], value: match[2] });
+                opts[match[1]] = match[2];
             }
 
             return opts;
         }
 
         /** Given a test file containing // @FileName directives, return an array of named units of code to be added to an existing compiler instance */
-        export function makeUnitsFromTest(code: string, fileName: string): { settings: CompilerSetting[]; testUnitData: TestUnitData[]; } {
+        export function makeUnitsFromTest(code: string, fileName: string): { settings: CompilerSettings; testUnitData: TestUnitData[]; } {
             let settings = extractCompilerSettings(code);
 
             // List of all the subfiles we've parsed out

src/harness/instrumenter.ts

@@ -3,11 +3,15 @@ var fs: any = require('fs');
 var path: any = require('path');
 
 function instrumentForRecording(fn: string, tscPath: string) {
-    instrument(tscPath, 'ts.sys = Playback.wrapSystem(ts.sys); ts.sys.startRecord("' + fn + '");', 'ts.sys.endRecord();');
+    instrument(tscPath, `
+ts.sys = Playback.wrapSystem(ts.sys);
+ts.sys.startRecord("${ fn }");`, `ts.sys.endRecord();`);
 }
 
 function instrumentForReplay(logFilename: string, tscPath: string) {
-    instrument(tscPath, 'ts.sys = Playback.wrapSystem(ts.sys); ts.sys.startReplay("' + logFilename + '");');
+    instrument(tscPath, `
+ts.sys = Playback.wrapSystem(ts.sys);
+ts.sys.startReplay("${ logFilename }");`);
 }
 
 function instrument(tscPath: string, prepareCode: string, cleanupCode: string = '') {

src/harness/loggedIO.ts

@@ -59,6 +59,12 @@ interface IOLog {
         path: string;
         result?: string;
     }[];
+    directoriesRead: {
+        path: string,
+        extension: string,
+        exclude: string[],
+        result: string[]
+    }[];
 }
 
 interface PlaybackControl {
@@ -95,12 +101,15 @@ module Playback {
 
     export interface PlaybackIO extends Harness.IO, PlaybackControl { }
 
+    export interface PlaybackSystem extends ts.System, PlaybackControl { }
+
     function createEmptyLog(): IOLog {
         return {
             timestamp: (new Date()).toString(),
             arguments: [],
             currentDirectory: "",
             filesRead: [],
+            directoriesRead: [],
             filesWritten: [],
             filesDeleted: [],
             filesAppended: [],
@@ -114,8 +123,10 @@ module Playback {
         };
     }
 
-    function initWrapper<T>(wrapper: PlaybackControl, underlying: T) {
-        Object.keys(underlying).forEach(prop => {
+    function initWrapper(wrapper: PlaybackSystem, underlying: ts.System): void;
+    function initWrapper(wrapper: PlaybackIO, underlying: Harness.IO): void;
+    function initWrapper(wrapper: PlaybackSystem | PlaybackIO, underlying: ts.System | Harness.IO): void {
+        ts.forEach(Object.keys(underlying), prop => {
             (<any>wrapper)[prop] = (<any>underlying)[prop];
         });
 
@@ -135,6 +146,93 @@ module Playback {
         wrapper.startRecord = (fileNameBase) => {
             recordLogFileNameBase = fileNameBase;
             recordLog = createEmptyLog();
+
+            if (typeof underlying.args !== "function") {
+                recordLog.arguments = <string[]>underlying.args;
+            }
+        };
+
+        wrapper.startReplayFromFile = logFn => {
+            wrapper.startReplayFromString(underlying.readFile(logFn));
+        };
+        wrapper.endRecord = () => {
+            if (recordLog !== undefined) {
+                let i = 0;
+                let fn = () => recordLogFileNameBase + i + ".json";
+                while (underlying.fileExists(fn())) i++;
+                underlying.writeFile(fn(), JSON.stringify(recordLog));
+                recordLog = undefined;
+            }
+        };
+
+        wrapper.fileExists = recordReplay(wrapper.fileExists, underlying)(
+            path => callAndRecord(underlying.fileExists(path), recordLog.fileExists, { path }),
+            memoize(path => {
+                // If we read from the file, it must exist
+                if (findResultByPath(wrapper, replayLog.filesRead, path, null) !== null) {
+                    return true;
+                }
+                else {
+                    return findResultByFields(replayLog.fileExists, { path }, false);
+                }
+            })
+        );
+
+        wrapper.getExecutingFilePath = () => {
+            if (replayLog !== undefined) {
+                return replayLog.executingPath;
+            }
+            else if (recordLog !== undefined) {
+                return recordLog.executingPath = underlying.getExecutingFilePath();
+            }
+            else {
+                return underlying.getExecutingFilePath();
+            }
+        };
+
+        wrapper.getCurrentDirectory = () => {
+            if (replayLog !== undefined) {
+                return replayLog.currentDirectory || "";
+            }
+            else if (recordLog !== undefined) {
+                return recordLog.currentDirectory = underlying.getCurrentDirectory();
+            }
+            else {
+                return underlying.getCurrentDirectory();
+            }
+        };
+
+        wrapper.resolvePath = recordReplay(wrapper.resolvePath, underlying)(
+            path => callAndRecord(underlying.resolvePath(path), recordLog.pathsResolved, { path }),
+            memoize(path => findResultByFields(replayLog.pathsResolved, { path }, !ts.isRootedDiskPath(ts.normalizeSlashes(path)) && replayLog.currentDirectory ? replayLog.currentDirectory + "/" + path : ts.normalizeSlashes(path))));
+
+        wrapper.readFile = recordReplay(wrapper.readFile, underlying)(
+            path => {
+                let result = underlying.readFile(path);
+                let logEntry = { path, codepage: 0, result: { contents: result, codepage: 0 } };
+                recordLog.filesRead.push(logEntry);
+                return result;
+            },
+            memoize(path => findResultByPath(wrapper, replayLog.filesRead, path).contents));
+
+        wrapper.readDirectory = recordReplay(wrapper.readDirectory, underlying)(
+            (path, extension, exclude) => {
+                let result = (<ts.System>underlying).readDirectory(path, extension, exclude);
+                let logEntry = { path, extension, exclude, result };
+                recordLog.directoriesRead.push(logEntry);
+                return result;
+            },
+            (path, extension, exclude) => findResultByPath(wrapper, replayLog.directoriesRead.filter(d => d.extension === extension && ts.arrayIsEqualTo(d.exclude, exclude)), path));
+
+        wrapper.writeFile = recordReplay(wrapper.writeFile, underlying)(
+            (path, contents) => callAndRecord(underlying.writeFile(path, contents), recordLog.filesWritten, { path, contents, bom: false }),
+            (path, contents) => noOpReplay("writeFile"));
+
+        wrapper.exit = (exitCode) => {
+            if (recordLog !== undefined) {
+                wrapper.endRecord();
+            }
+            underlying.exit(exitCode);
         };
     }
 
@@ -143,9 +241,11 @@ module Playback {
             return <any>(function () {
                 if (replayLog !== undefined) {
                     return replay.apply(undefined, arguments);
-                } else if (recordLog !== undefined) {
+                }
+                else if (recordLog !== undefined) {
                     return record.apply(undefined, arguments);
-                } else {
+                }
+                else {
                     return original.apply(underlying, arguments);
                 }
             });
@@ -169,7 +269,8 @@ module Playback {
         if (results.length === 0) {
             if (defaultValue !== undefined) {
                 return defaultValue;
-            } else {
+            }
+            else {
                 throw new Error("No matching result in log array for: " + JSON.stringify(expectedFields));
             }
         }
@@ -177,7 +278,7 @@ module Playback {
     }
 
     function findResultByPath<T>(wrapper: { resolvePath(s: string): string }, logArray: { path: string; result?: T }[], expectedPath: string, defaultValue?: T): T {
-        let normalizedName = ts.normalizeSlashes(expectedPath).toLowerCase();
+        let normalizedName = ts.normalizePath(expectedPath).toLowerCase();
         // Try to find the result through normal fileName
         for (let i = 0; i < logArray.length; i++) {
             if (ts.normalizeSlashes(logArray[i].path).toLowerCase() === normalizedName) {
@@ -193,10 +294,12 @@ module Playback {
                 }
             }
         }
+
         // If we got here, we didn't find a match
         if (defaultValue === undefined) {
             throw new Error("No matching result in log array for path: " + expectedPath);
-        } else {
+        }
+        else {
             return defaultValue;
         }
     }
@@ -214,7 +317,8 @@ module Playback {
         }
         if (pathEquivCache.hasOwnProperty(key)) {
             return pathEquivCache[key];
-        } else {
+        }
+        else {
             return pathEquivCache[key] = check();
         }
     }
@@ -227,93 +331,18 @@ module Playback {
         let wrapper: PlaybackIO = <any>{};
         initWrapper(wrapper, underlying);
 
-        wrapper.startReplayFromFile = logFn => {
-            wrapper.startReplayFromString(underlying.readFile(logFn));
-        };
-        wrapper.endRecord = () => {
-            if (recordLog !== undefined) {
-                let i = 0;
-                let fn = () => recordLogFileNameBase + i + ".json";
-                while (underlying.fileExists(fn())) i++;
-                underlying.writeFile(fn(), JSON.stringify(recordLog));
-                recordLog = undefined;
-            }
-        };
-        
-        wrapper.args = () => {
-            if (replayLog !== undefined) {
-                return replayLog.arguments;
-            } else if (recordLog !== undefined) {
-                recordLog.arguments = underlying.args();
-            }
-            return underlying.args();
-        }
-        
-        wrapper.newLine = () => underlying.newLine();
-        wrapper.useCaseSensitiveFileNames = () => underlying.useCaseSensitiveFileNames();
         wrapper.directoryName = (path): string => { throw new Error("NotSupported"); };
-        wrapper.createDirectory = path => { throw new Error("NotSupported"); };
+        wrapper.createDirectory = (path): void => { throw new Error("NotSupported"); };
         wrapper.directoryExists = (path): boolean => { throw new Error("NotSupported"); };
-        wrapper.deleteFile = path => { throw new Error("NotSupported"); };
+        wrapper.deleteFile = (path): void => { throw new Error("NotSupported"); };
         wrapper.listFiles = (path, filter, options): string[] => { throw new Error("NotSupported"); };
-        wrapper.log = text => underlying.log(text);
-
-        wrapper.fileExists = recordReplay(wrapper.fileExists, underlying)(
-            (path) => callAndRecord(underlying.fileExists(path), recordLog.fileExists, { path: path }),
-            memoize((path) => {
-                // If we read from the file, it must exist
-                if (findResultByPath(wrapper, replayLog.filesRead, path, null) !== null) {
-                    return true;
-                } else {
-                    return findResultByFields(replayLog.fileExists, { path: path }, false);
-                }
-            })
-        );
-
-        wrapper.getExecutingFilePath = () => {
-            if (replayLog !== undefined) {
-                return replayLog.executingPath;
-            } else if (recordLog !== undefined) {
-                return recordLog.executingPath = underlying.getExecutingFilePath();
-            } else {
-                return underlying.getExecutingFilePath();
-            }
-        };
-
-        wrapper.getCurrentDirectory = () => {
-            if (replayLog !== undefined) {
-                return replayLog.currentDirectory || "";
-            } else if (recordLog !== undefined) {
-                return recordLog.currentDirectory = underlying.getCurrentDirectory();
-            } else {
-                return underlying.getCurrentDirectory();
-            }
-        };
-
-        wrapper.resolvePath = recordReplay(wrapper.resolvePath, underlying)(
-            (path) => callAndRecord(underlying.resolvePath(path), recordLog.pathsResolved, { path: path }),
-            memoize((path) => findResultByFields(replayLog.pathsResolved, { path: path }, !ts.isRootedDiskPath(ts.normalizeSlashes(path)) && replayLog.currentDirectory ? replayLog.currentDirectory + "/" + path : ts.normalizeSlashes(path))));
-
-        wrapper.readFile = recordReplay(wrapper.readFile, underlying)(
-            (path) => {
-                let result = underlying.readFile(path);
-                let logEntry = { path: path, codepage: 0, result: { contents: result, codepage: 0 } };
-                recordLog.filesRead.push(logEntry);
-                return result;
-            },
-            memoize((path) => findResultByPath(wrapper, replayLog.filesRead, path).contents));
-
-        wrapper.writeFile = recordReplay(wrapper.writeFile, underlying)(
-            (path, contents) => callAndRecord(underlying.writeFile(path, contents), recordLog.filesWritten, { path: path, contents: contents, bom: false }),
-            (path, contents) => noOpReplay("writeFile"));
-
-        wrapper.exit = (exitCode) => {
-            if (recordLog !== undefined) {
-                wrapper.endRecord();
-            }
-            underlying.exit(exitCode);
-        };
 
         return wrapper;
     }
+
+    export function wrapSystem(underlying: ts.System): PlaybackSystem {
+        let wrapper: PlaybackSystem = <any>{};
+        initWrapper(wrapper, underlying);
+        return wrapper;
+    }
 }

src/harness/rwcRunner.ts

@@ -19,6 +19,11 @@ module RWC {
         }
     }
 
+    function isTsConfigFile(file: { path: string }): boolean {
+        const tsConfigFileName = "tsconfig.json";
+        return file.path.substr(file.path.length - tsConfigFileName.length).toLowerCase() === tsConfigFileName;
+    }
+
     export function runRWCTest(jsonPath: string) {
         describe("Testing a RWC project: " + jsonPath, () => {
             let inputFiles: { unitName: string; content: string; }[] = [];
@@ -67,10 +72,21 @@ module RWC {
                 runWithIOLog(ioLog, oldIO => {
                     harnessCompiler.reset();
 
+                    let fileNames = opts.fileNames;
+
+                    let tsconfigFile = ts.forEach(ioLog.filesRead, f => isTsConfigFile(f) ? f : undefined);
+                    if (tsconfigFile) {
+                        let tsconfigFileContents = getHarnessCompilerInputUnit(tsconfigFile.path);
+                        let parsedTsconfigFileContents = ts.parseConfigFileText(tsconfigFile.path, tsconfigFileContents.content);
+                        let configParseResult = ts.parseConfigFile(parsedTsconfigFileContents.config, Harness.IO, ts.getDirectoryPath(tsconfigFile.path));
+                        fileNames = configParseResult.fileNames;
+                        opts.options = ts.extend(opts.options, configParseResult.options);
+                    }
+
                     // Load the files
-                    ts.forEach(opts.fileNames, fileName => {
+                    for (let fileName of fileNames) {
                         inputFiles.push(getHarnessCompilerInputUnit(fileName));
-                    });
+                    }
 
                     // Add files to compilation
                     let isInInputList = (resolvedPath: string) => (inputFile: { unitName: string; content: string; }) => inputFile.unitName === resolvedPath;
@@ -79,6 +95,10 @@ module RWC {
                         const resolvedPath = ts.normalizeSlashes(Harness.IO.resolvePath(fileRead.path));
                         let inInputList = ts.forEach(inputFiles, isInInputList(resolvedPath));
 
+                        if (isTsConfigFile(fileRead)) {
+                            continue;
+                        }
+
                         if (!Harness.isLibraryFile(fileRead.path)) {
                             if (inInputList) {
                                 continue;

src/services/services.ts

@@ -2152,6 +2152,7 @@ namespace ts {
             //
             //    export * from "mod"
             //    export {a as b} from "mod"
+            //    export import i = require("mod")
 
             while (token !== SyntaxKind.EndOfFileToken) {
                 if (token === SyntaxKind.DeclareKeyword) {
@@ -2276,6 +2277,25 @@ namespace ts {
                             }
                         }
                     }
+                    else if (token === SyntaxKind.ImportKeyword) {
+                        token = scanner.scan();
+                        if (token === SyntaxKind.Identifier || isKeyword(token)) {
+                            token = scanner.scan();
+                            if (token === SyntaxKind.EqualsToken) {
+                                token = scanner.scan();
+                                if (token === SyntaxKind.RequireKeyword) {
+                                    token = scanner.scan();
+                                    if (token === SyntaxKind.OpenParenToken) {
+                                        token = scanner.scan();
+                                        if (token === SyntaxKind.StringLiteral) {
+                                            //  export import i = require("mod");
+                                            recordModuleName();
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
                 token = scanner.scan();
             }

tests/baselines/reference/aliasAssignments.errors.txt

@@ -4,7 +4,7 @@ tests/cases/compiler/aliasAssignments_1.ts(5,1): error TS2322: Type 'typeof "tes
 
 
 ==== tests/cases/compiler/aliasAssignments_1.ts (2 errors) ====
-    import moduleA = require("aliasAssignments_moduleA");
+    import moduleA = require("./aliasAssignments_moduleA");
     var x = moduleA;
     x = 1; // Should be error
     ~

tests/baselines/reference/aliasAssignments.js

@@ -6,7 +6,7 @@ export class someClass {
 }
 
 //// [aliasAssignments_1.ts]
-import moduleA = require("aliasAssignments_moduleA");
+import moduleA = require("./aliasAssignments_moduleA");
 var x = moduleA;
 x = 1; // Should be error
 var y = 1;
@@ -21,7 +21,7 @@ var someClass = (function () {
 })();
 exports.someClass = someClass;
 //// [aliasAssignments_1.js]
-var moduleA = require("aliasAssignments_moduleA");
+var moduleA = require("./aliasAssignments_moduleA");
 var x = moduleA;
 x = 1; // Should be error
 var y = 1;

tests/baselines/reference/aliasUsageInAccessorsOfClass.js

@@ -6,14 +6,14 @@ export class Model {
 }
 
 //// [aliasUsage1_moduleA.ts]
-import Backbone = require("aliasUsage1_backbone");
+import Backbone = require("./aliasUsage1_backbone");
 export class VisualizationModel extends Backbone.Model {
     // interesting stuff here
 }
 
 //// [aliasUsage1_main.ts]
-import Backbone = require("aliasUsage1_backbone");
-import moduleA = require("aliasUsage1_moduleA");
+import Backbone = require("./aliasUsage1_backbone");
+import moduleA = require("./aliasUsage1_moduleA");
 interface IHasVisualizationModel {
     VisualizationModel: typeof Backbone.Model;
 }
@@ -40,7 +40,7 @@ var __extends = (this && this.__extends) || function (d, b) {
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
-var Backbone = require("aliasUsage1_backbone");
+var Backbone = require("./aliasUsage1_backbone");
 var VisualizationModel = (function (_super) {
     __extends(VisualizationModel, _super);
     function VisualizationModel() {
@@ -50,7 +50,7 @@ var VisualizationModel = (function (_super) {
 })(Backbone.Model);
 exports.VisualizationModel = VisualizationModel;
 //// [aliasUsage1_main.js]
-var moduleA = require("aliasUsage1_moduleA");
+var moduleA = require("./aliasUsage1_moduleA");
 var C2 = (function () {
     function C2() {
     }

tests/baselines/reference/aliasUsageInAccessorsOfClass.symbols

@@ -1,12 +1,12 @@
 === tests/cases/compiler/aliasUsage1_main.ts ===
-import Backbone = require("aliasUsage1_backbone");
+import Backbone = require("./aliasUsage1_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsage1_main.ts, 0, 0))
 
-import moduleA = require("aliasUsage1_moduleA");
->moduleA : Symbol(moduleA, Decl(aliasUsage1_main.ts, 0, 50))
+import moduleA = require("./aliasUsage1_moduleA");
+>moduleA : Symbol(moduleA, Decl(aliasUsage1_main.ts, 0, 52))
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsage1_main.ts, 1, 48))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsage1_main.ts, 1, 50))
 
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsage1_main.ts, 2, 34))
@@ -19,7 +19,7 @@ class C2 {
 
     x: IHasVisualizationModel;
 >x : Symbol(x, Decl(aliasUsage1_main.ts, 5, 10))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsage1_main.ts, 1, 48))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsage1_main.ts, 1, 50))
 
     get A() {
 >A : Symbol(A, Decl(aliasUsage1_main.ts, 6, 30), Decl(aliasUsage1_main.ts, 9, 5))
@@ -35,7 +35,7 @@ class C2 {
 
         x = moduleA;
 >x : Symbol(x, Decl(aliasUsage1_main.ts, 10, 10))
->moduleA : Symbol(moduleA, Decl(aliasUsage1_main.ts, 0, 50))
+>moduleA : Symbol(moduleA, Decl(aliasUsage1_main.ts, 0, 52))
     }
 }
 === tests/cases/compiler/aliasUsage1_backbone.ts ===
@@ -47,11 +47,11 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsage1_moduleA.ts ===
-import Backbone = require("aliasUsage1_backbone");
+import Backbone = require("./aliasUsage1_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsage1_moduleA.ts, 0, 0))
 
 export class VisualizationModel extends Backbone.Model {
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsage1_moduleA.ts, 0, 50))
+>VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsage1_moduleA.ts, 0, 52))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsage1_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsage1_moduleA.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsage1_backbone.ts, 0, 0))

tests/baselines/reference/aliasUsageInAccessorsOfClass.types

@@ -1,8 +1,8 @@
 === tests/cases/compiler/aliasUsage1_main.ts ===
-import Backbone = require("aliasUsage1_backbone");
+import Backbone = require("./aliasUsage1_backbone");
 >Backbone : typeof Backbone
 
-import moduleA = require("aliasUsage1_moduleA");
+import moduleA = require("./aliasUsage1_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
@@ -48,7 +48,7 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsage1_moduleA.ts ===
-import Backbone = require("aliasUsage1_backbone");
+import Backbone = require("./aliasUsage1_backbone");
 >Backbone : typeof Backbone
 
 export class VisualizationModel extends Backbone.Model {

tests/baselines/reference/aliasUsageInArray.js

@@ -6,14 +6,14 @@ export class Model {
 }
 
 //// [aliasUsageInArray_moduleA.ts]
-import Backbone = require("aliasUsageInArray_backbone");
+import Backbone = require("./aliasUsageInArray_backbone");
 export class VisualizationModel extends Backbone.Model {
     // interesting stuff here
 }
 
 //// [aliasUsageInArray_main.ts]
-import Backbone = require("aliasUsageInArray_backbone");
-import moduleA = require("aliasUsageInArray_moduleA");
+import Backbone = require("./aliasUsageInArray_backbone");
+import moduleA = require("./aliasUsageInArray_moduleA");
 interface IHasVisualizationModel {
     VisualizationModel: typeof Backbone.Model;
 }
@@ -34,7 +34,7 @@ var __extends = (this && this.__extends) || function (d, b) {
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
-var Backbone = require("aliasUsageInArray_backbone");
+var Backbone = require("./aliasUsageInArray_backbone");
 var VisualizationModel = (function (_super) {
     __extends(VisualizationModel, _super);
     function VisualizationModel() {
@@ -44,6 +44,6 @@ var VisualizationModel = (function (_super) {
 })(Backbone.Model);
 exports.VisualizationModel = VisualizationModel;
 //// [aliasUsageInArray_main.js]
-var moduleA = require("aliasUsageInArray_moduleA");
+var moduleA = require("./aliasUsageInArray_moduleA");
 var xs = [moduleA];
 var xs2 = [moduleA];

tests/baselines/reference/aliasUsageInArray.symbols

@@ -1,12 +1,12 @@
 === tests/cases/compiler/aliasUsageInArray_main.ts ===
-import Backbone = require("aliasUsageInArray_backbone");
+import Backbone = require("./aliasUsageInArray_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInArray_main.ts, 0, 0))
 
-import moduleA = require("aliasUsageInArray_moduleA");
->moduleA : Symbol(moduleA, Decl(aliasUsageInArray_main.ts, 0, 56))
+import moduleA = require("./aliasUsageInArray_moduleA");
+>moduleA : Symbol(moduleA, Decl(aliasUsageInArray_main.ts, 0, 58))
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInArray_main.ts, 1, 54))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInArray_main.ts, 1, 56))
 
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInArray_main.ts, 2, 34))
@@ -17,13 +17,13 @@ interface IHasVisualizationModel {
 
 var xs: IHasVisualizationModel[] = [moduleA];
 >xs : Symbol(xs, Decl(aliasUsageInArray_main.ts, 6, 3))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInArray_main.ts, 1, 54))
->moduleA : Symbol(moduleA, Decl(aliasUsageInArray_main.ts, 0, 56))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInArray_main.ts, 1, 56))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInArray_main.ts, 0, 58))
 
 var xs2: typeof moduleA[] = [moduleA];
 >xs2 : Symbol(xs2, Decl(aliasUsageInArray_main.ts, 7, 3))
->moduleA : Symbol(moduleA, Decl(aliasUsageInArray_main.ts, 0, 56))
->moduleA : Symbol(moduleA, Decl(aliasUsageInArray_main.ts, 0, 56))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInArray_main.ts, 0, 58))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInArray_main.ts, 0, 58))
 
 === tests/cases/compiler/aliasUsageInArray_backbone.ts ===
 export class Model {
@@ -34,11 +34,11 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInArray_moduleA.ts ===
-import Backbone = require("aliasUsageInArray_backbone");
+import Backbone = require("./aliasUsageInArray_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInArray_moduleA.ts, 0, 0))
 
 export class VisualizationModel extends Backbone.Model {
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInArray_moduleA.ts, 0, 56))
+>VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInArray_moduleA.ts, 0, 58))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInArray_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInArray_moduleA.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInArray_backbone.ts, 0, 0))

tests/baselines/reference/aliasUsageInArray.types

@@ -1,8 +1,8 @@
 === tests/cases/compiler/aliasUsageInArray_main.ts ===
-import Backbone = require("aliasUsageInArray_backbone");
+import Backbone = require("./aliasUsageInArray_backbone");
 >Backbone : typeof Backbone
 
-import moduleA = require("aliasUsageInArray_moduleA");
+import moduleA = require("./aliasUsageInArray_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
@@ -36,7 +36,7 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInArray_moduleA.ts ===
-import Backbone = require("aliasUsageInArray_backbone");
+import Backbone = require("./aliasUsageInArray_backbone");
 >Backbone : typeof Backbone
 
 export class VisualizationModel extends Backbone.Model {

tests/baselines/reference/aliasUsageInFunctionExpression.js

@@ -6,14 +6,14 @@ export class Model {
 }
 
 //// [aliasUsageInFunctionExpression_moduleA.ts]
-import Backbone = require("aliasUsageInFunctionExpression_backbone");
+import Backbone = require("./aliasUsageInFunctionExpression_backbone");
 export class VisualizationModel extends Backbone.Model {
     // interesting stuff here
 }
 
 //// [aliasUsageInFunctionExpression_main.ts]
-import Backbone = require("aliasUsageInFunctionExpression_backbone");
-import moduleA = require("aliasUsageInFunctionExpression_moduleA");
+import Backbone = require("./aliasUsageInFunctionExpression_backbone");
+import moduleA = require("./aliasUsageInFunctionExpression_moduleA");
 interface IHasVisualizationModel {
     VisualizationModel: typeof Backbone.Model;
 }
@@ -33,7 +33,7 @@ var __extends = (this && this.__extends) || function (d, b) {
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
-var Backbone = require("aliasUsageInFunctionExpression_backbone");
+var Backbone = require("./aliasUsageInFunctionExpression_backbone");
 var VisualizationModel = (function (_super) {
     __extends(VisualizationModel, _super);
     function VisualizationModel() {
@@ -43,6 +43,6 @@ var VisualizationModel = (function (_super) {
 })(Backbone.Model);
 exports.VisualizationModel = VisualizationModel;
 //// [aliasUsageInFunctionExpression_main.js]
-var moduleA = require("aliasUsageInFunctionExpression_moduleA");
+var moduleA = require("./aliasUsageInFunctionExpression_moduleA");
 var f = function (x) { return x; };
 f = function (x) { return moduleA; };

tests/baselines/reference/aliasUsageInFunctionExpression.symbols

@@ -1,12 +1,12 @@
 === tests/cases/compiler/aliasUsageInFunctionExpression_main.ts ===
-import Backbone = require("aliasUsageInFunctionExpression_backbone");
+import Backbone = require("./aliasUsageInFunctionExpression_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInFunctionExpression_main.ts, 0, 0))
 
-import moduleA = require("aliasUsageInFunctionExpression_moduleA");
->moduleA : Symbol(moduleA, Decl(aliasUsageInFunctionExpression_main.ts, 0, 69))
+import moduleA = require("./aliasUsageInFunctionExpression_moduleA");
+>moduleA : Symbol(moduleA, Decl(aliasUsageInFunctionExpression_main.ts, 0, 71))
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInFunctionExpression_main.ts, 1, 67))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInFunctionExpression_main.ts, 1, 69))
 
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInFunctionExpression_main.ts, 2, 34))
@@ -17,13 +17,13 @@ interface IHasVisualizationModel {
 var f = (x: IHasVisualizationModel) => x;
 >f : Symbol(f, Decl(aliasUsageInFunctionExpression_main.ts, 5, 3))
 >x : Symbol(x, Decl(aliasUsageInFunctionExpression_main.ts, 5, 9))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInFunctionExpression_main.ts, 1, 67))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInFunctionExpression_main.ts, 1, 69))
 >x : Symbol(x, Decl(aliasUsageInFunctionExpression_main.ts, 5, 9))
 
 f = (x) => moduleA;
 >f : Symbol(f, Decl(aliasUsageInFunctionExpression_main.ts, 5, 3))
 >x : Symbol(x, Decl(aliasUsageInFunctionExpression_main.ts, 6, 5))
->moduleA : Symbol(moduleA, Decl(aliasUsageInFunctionExpression_main.ts, 0, 69))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInFunctionExpression_main.ts, 0, 71))
 
 === tests/cases/compiler/aliasUsageInFunctionExpression_backbone.ts ===
 export class Model {
@@ -34,11 +34,11 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInFunctionExpression_moduleA.ts ===
-import Backbone = require("aliasUsageInFunctionExpression_backbone");
+import Backbone = require("./aliasUsageInFunctionExpression_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInFunctionExpression_moduleA.ts, 0, 0))
 
 export class VisualizationModel extends Backbone.Model {
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInFunctionExpression_moduleA.ts, 0, 69))
+>VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInFunctionExpression_moduleA.ts, 0, 71))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInFunctionExpression_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInFunctionExpression_moduleA.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInFunctionExpression_backbone.ts, 0, 0))

tests/baselines/reference/aliasUsageInFunctionExpression.types

@@ -1,8 +1,8 @@
 === tests/cases/compiler/aliasUsageInFunctionExpression_main.ts ===
-import Backbone = require("aliasUsageInFunctionExpression_backbone");
+import Backbone = require("./aliasUsageInFunctionExpression_backbone");
 >Backbone : typeof Backbone
 
-import moduleA = require("aliasUsageInFunctionExpression_moduleA");
+import moduleA = require("./aliasUsageInFunctionExpression_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
@@ -37,7 +37,7 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInFunctionExpression_moduleA.ts ===
-import Backbone = require("aliasUsageInFunctionExpression_backbone");
+import Backbone = require("./aliasUsageInFunctionExpression_backbone");
 >Backbone : typeof Backbone
 
 export class VisualizationModel extends Backbone.Model {

tests/baselines/reference/aliasUsageInGenericFunction.js

@@ -6,14 +6,14 @@ export class Model {
 }
 
 //// [aliasUsageInGenericFunction_moduleA.ts]
-import Backbone = require("aliasUsageInGenericFunction_backbone");
+import Backbone = require("./aliasUsageInGenericFunction_backbone");
 export class VisualizationModel extends Backbone.Model {
     // interesting stuff here
 }
 
 //// [aliasUsageInGenericFunction_main.ts]
-import Backbone = require("aliasUsageInGenericFunction_backbone");
-import moduleA = require("aliasUsageInGenericFunction_moduleA");
+import Backbone = require("./aliasUsageInGenericFunction_backbone");
+import moduleA = require("./aliasUsageInGenericFunction_moduleA");
 interface IHasVisualizationModel {
     VisualizationModel: typeof Backbone.Model;
 }
@@ -37,7 +37,7 @@ var __extends = (this && this.__extends) || function (d, b) {
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
-var Backbone = require("aliasUsageInGenericFunction_backbone");
+var Backbone = require("./aliasUsageInGenericFunction_backbone");
 var VisualizationModel = (function (_super) {
     __extends(VisualizationModel, _super);
     function VisualizationModel() {
@@ -47,7 +47,7 @@ var VisualizationModel = (function (_super) {
 })(Backbone.Model);
 exports.VisualizationModel = VisualizationModel;
 //// [aliasUsageInGenericFunction_main.js]
-var moduleA = require("aliasUsageInGenericFunction_moduleA");
+var moduleA = require("./aliasUsageInGenericFunction_moduleA");
 function foo(x) {
     return x;
 }

tests/baselines/reference/aliasUsageInGenericFunction.symbols

@@ -1,12 +1,12 @@
 === tests/cases/compiler/aliasUsageInGenericFunction_main.ts ===
-import Backbone = require("aliasUsageInGenericFunction_backbone");
+import Backbone = require("./aliasUsageInGenericFunction_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInGenericFunction_main.ts, 0, 0))
 
-import moduleA = require("aliasUsageInGenericFunction_moduleA");
->moduleA : Symbol(moduleA, Decl(aliasUsageInGenericFunction_main.ts, 0, 66))
+import moduleA = require("./aliasUsageInGenericFunction_moduleA");
+>moduleA : Symbol(moduleA, Decl(aliasUsageInGenericFunction_main.ts, 0, 68))
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 1, 64))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 1, 66))
 
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 2, 34))
@@ -18,7 +18,7 @@ function foo<T extends { a: IHasVisualizationModel }>(x: T) {
 >foo : Symbol(foo, Decl(aliasUsageInGenericFunction_main.ts, 4, 1))
 >T : Symbol(T, Decl(aliasUsageInGenericFunction_main.ts, 5, 13))
 >a : Symbol(a, Decl(aliasUsageInGenericFunction_main.ts, 5, 24))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 1, 64))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 1, 66))
 >x : Symbol(x, Decl(aliasUsageInGenericFunction_main.ts, 5, 54))
 >T : Symbol(T, Decl(aliasUsageInGenericFunction_main.ts, 5, 13))
 
@@ -29,13 +29,13 @@ var r = foo({ a: moduleA });
 >r : Symbol(r, Decl(aliasUsageInGenericFunction_main.ts, 8, 3))
 >foo : Symbol(foo, Decl(aliasUsageInGenericFunction_main.ts, 4, 1))
 >a : Symbol(a, Decl(aliasUsageInGenericFunction_main.ts, 8, 13))
->moduleA : Symbol(moduleA, Decl(aliasUsageInGenericFunction_main.ts, 0, 66))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInGenericFunction_main.ts, 0, 68))
 
 var r2 = foo({ a: <IHasVisualizationModel>null });
 >r2 : Symbol(r2, Decl(aliasUsageInGenericFunction_main.ts, 9, 3))
 >foo : Symbol(foo, Decl(aliasUsageInGenericFunction_main.ts, 4, 1))
 >a : Symbol(a, Decl(aliasUsageInGenericFunction_main.ts, 9, 14))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 1, 64))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 1, 66))
 
 === tests/cases/compiler/aliasUsageInGenericFunction_backbone.ts ===
 export class Model {
@@ -46,11 +46,11 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInGenericFunction_moduleA.ts ===
-import Backbone = require("aliasUsageInGenericFunction_backbone");
+import Backbone = require("./aliasUsageInGenericFunction_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInGenericFunction_moduleA.ts, 0, 0))
 
 export class VisualizationModel extends Backbone.Model {
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInGenericFunction_moduleA.ts, 0, 66))
+>VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInGenericFunction_moduleA.ts, 0, 68))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInGenericFunction_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInGenericFunction_moduleA.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInGenericFunction_backbone.ts, 0, 0))

tests/baselines/reference/aliasUsageInGenericFunction.types

@@ -1,8 +1,8 @@
 === tests/cases/compiler/aliasUsageInGenericFunction_main.ts ===
-import Backbone = require("aliasUsageInGenericFunction_backbone");
+import Backbone = require("./aliasUsageInGenericFunction_backbone");
 >Backbone : typeof Backbone
 
-import moduleA = require("aliasUsageInGenericFunction_moduleA");
+import moduleA = require("./aliasUsageInGenericFunction_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
@@ -52,7 +52,7 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInGenericFunction_moduleA.ts ===
-import Backbone = require("aliasUsageInGenericFunction_backbone");
+import Backbone = require("./aliasUsageInGenericFunction_backbone");
 >Backbone : typeof Backbone
 
 export class VisualizationModel extends Backbone.Model {

tests/baselines/reference/aliasUsageInIndexerOfClass.js

@@ -6,14 +6,14 @@ export class Model {
 }
 
 //// [aliasUsageInIndexerOfClass_moduleA.ts]
-import Backbone = require("aliasUsageInIndexerOfClass_backbone");
+import Backbone = require("./aliasUsageInIndexerOfClass_backbone");
 export class VisualizationModel extends Backbone.Model {
     // interesting stuff here
 }
 
 //// [aliasUsageInIndexerOfClass_main.ts]
-import Backbone = require("aliasUsageInIndexerOfClass_backbone");
-import moduleA = require("aliasUsageInIndexerOfClass_moduleA");
+import Backbone = require("./aliasUsageInIndexerOfClass_backbone");
+import moduleA = require("./aliasUsageInIndexerOfClass_moduleA");
 interface IHasVisualizationModel {
     VisualizationModel: typeof Backbone.Model;
 }
@@ -39,7 +39,7 @@ var __extends = (this && this.__extends) || function (d, b) {
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
-var Backbone = require("aliasUsageInIndexerOfClass_backbone");
+var Backbone = require("./aliasUsageInIndexerOfClass_backbone");
 var VisualizationModel = (function (_super) {
     __extends(VisualizationModel, _super);
     function VisualizationModel() {
@@ -49,7 +49,7 @@ var VisualizationModel = (function (_super) {
 })(Backbone.Model);
 exports.VisualizationModel = VisualizationModel;
 //// [aliasUsageInIndexerOfClass_main.js]
-var moduleA = require("aliasUsageInIndexerOfClass_moduleA");
+var moduleA = require("./aliasUsageInIndexerOfClass_moduleA");
 var N = (function () {
     function N() {
         this.x = moduleA;

tests/baselines/reference/aliasUsageInIndexerOfClass.symbols

@@ -1,12 +1,12 @@
 === tests/cases/compiler/aliasUsageInIndexerOfClass_main.ts ===
-import Backbone = require("aliasUsageInIndexerOfClass_backbone");
+import Backbone = require("./aliasUsageInIndexerOfClass_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInIndexerOfClass_main.ts, 0, 0))
 
-import moduleA = require("aliasUsageInIndexerOfClass_moduleA");
->moduleA : Symbol(moduleA, Decl(aliasUsageInIndexerOfClass_main.ts, 0, 65))
+import moduleA = require("./aliasUsageInIndexerOfClass_moduleA");
+>moduleA : Symbol(moduleA, Decl(aliasUsageInIndexerOfClass_main.ts, 0, 67))
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInIndexerOfClass_main.ts, 1, 63))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInIndexerOfClass_main.ts, 1, 65))
 
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInIndexerOfClass_main.ts, 2, 34))
@@ -19,22 +19,22 @@ class N {
 
     [idx: string]: IHasVisualizationModel
 >idx : Symbol(idx, Decl(aliasUsageInIndexerOfClass_main.ts, 6, 5))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInIndexerOfClass_main.ts, 1, 63))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInIndexerOfClass_main.ts, 1, 65))
 
     x = moduleA;
 >x : Symbol(x, Decl(aliasUsageInIndexerOfClass_main.ts, 6, 41))
->moduleA : Symbol(moduleA, Decl(aliasUsageInIndexerOfClass_main.ts, 0, 65))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInIndexerOfClass_main.ts, 0, 67))
 }
 class N2 {
 >N2 : Symbol(N2, Decl(aliasUsageInIndexerOfClass_main.ts, 8, 1))
 
     [idx: string]: typeof moduleA
 >idx : Symbol(idx, Decl(aliasUsageInIndexerOfClass_main.ts, 10, 5))
->moduleA : Symbol(moduleA, Decl(aliasUsageInIndexerOfClass_main.ts, 0, 65))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInIndexerOfClass_main.ts, 0, 67))
 
     x: IHasVisualizationModel;
 >x : Symbol(x, Decl(aliasUsageInIndexerOfClass_main.ts, 10, 33))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInIndexerOfClass_main.ts, 1, 63))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInIndexerOfClass_main.ts, 1, 65))
 }
 === tests/cases/compiler/aliasUsageInIndexerOfClass_backbone.ts ===
 export class Model {
@@ -45,11 +45,11 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInIndexerOfClass_moduleA.ts ===
-import Backbone = require("aliasUsageInIndexerOfClass_backbone");
+import Backbone = require("./aliasUsageInIndexerOfClass_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInIndexerOfClass_moduleA.ts, 0, 0))
 
 export class VisualizationModel extends Backbone.Model {
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInIndexerOfClass_moduleA.ts, 0, 65))
+>VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInIndexerOfClass_moduleA.ts, 0, 67))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInIndexerOfClass_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInIndexerOfClass_moduleA.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInIndexerOfClass_backbone.ts, 0, 0))

tests/baselines/reference/aliasUsageInIndexerOfClass.types

@@ -1,8 +1,8 @@
 === tests/cases/compiler/aliasUsageInIndexerOfClass_main.ts ===
-import Backbone = require("aliasUsageInIndexerOfClass_backbone");
+import Backbone = require("./aliasUsageInIndexerOfClass_backbone");
 >Backbone : typeof Backbone
 
-import moduleA = require("aliasUsageInIndexerOfClass_moduleA");
+import moduleA = require("./aliasUsageInIndexerOfClass_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
@@ -45,7 +45,7 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInIndexerOfClass_moduleA.ts ===
-import Backbone = require("aliasUsageInIndexerOfClass_backbone");
+import Backbone = require("./aliasUsageInIndexerOfClass_backbone");
 >Backbone : typeof Backbone
 
 export class VisualizationModel extends Backbone.Model {

tests/baselines/reference/aliasUsageInObjectLiteral.js

@@ -6,14 +6,14 @@ export class Model {
 }
 
 //// [aliasUsageInObjectLiteral_moduleA.ts]
-import Backbone = require("aliasUsageInObjectLiteral_backbone");
+import Backbone = require("./aliasUsageInObjectLiteral_backbone");
 export class VisualizationModel extends Backbone.Model {
     // interesting stuff here
 }
 
 //// [aliasUsageInObjectLiteral_main.ts]
-import Backbone = require("aliasUsageInObjectLiteral_backbone");
-import moduleA = require("aliasUsageInObjectLiteral_moduleA");
+import Backbone = require("./aliasUsageInObjectLiteral_backbone");
+import moduleA = require("./aliasUsageInObjectLiteral_moduleA");
 interface IHasVisualizationModel {
     VisualizationModel: typeof Backbone.Model;
 }
@@ -34,7 +34,7 @@ var __extends = (this && this.__extends) || function (d, b) {
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
-var Backbone = require("aliasUsageInObjectLiteral_backbone");
+var Backbone = require("./aliasUsageInObjectLiteral_backbone");
 var VisualizationModel = (function (_super) {
     __extends(VisualizationModel, _super);
     function VisualizationModel() {
@@ -44,7 +44,7 @@ var VisualizationModel = (function (_super) {
 })(Backbone.Model);
 exports.VisualizationModel = VisualizationModel;
 //// [aliasUsageInObjectLiteral_main.js]
-var moduleA = require("aliasUsageInObjectLiteral_moduleA");
+var moduleA = require("./aliasUsageInObjectLiteral_moduleA");
 var a = { x: moduleA };
 var b = { x: moduleA };
 var c = { y: { z: moduleA } };

tests/baselines/reference/aliasUsageInObjectLiteral.symbols

@@ -1,12 +1,12 @@
 === tests/cases/compiler/aliasUsageInObjectLiteral_main.ts ===
-import Backbone = require("aliasUsageInObjectLiteral_backbone");
+import Backbone = require("./aliasUsageInObjectLiteral_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInObjectLiteral_main.ts, 0, 0))
 
-import moduleA = require("aliasUsageInObjectLiteral_moduleA");
->moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 64))
+import moduleA = require("./aliasUsageInObjectLiteral_moduleA");
+>moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 66))
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInObjectLiteral_main.ts, 1, 62))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInObjectLiteral_main.ts, 1, 64))
 
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInObjectLiteral_main.ts, 2, 34))
@@ -17,25 +17,25 @@ interface IHasVisualizationModel {
 var a: { x: typeof moduleA } = { x: moduleA };
 >a : Symbol(a, Decl(aliasUsageInObjectLiteral_main.ts, 5, 3))
 >x : Symbol(x, Decl(aliasUsageInObjectLiteral_main.ts, 5, 8))
->moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 64))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 66))
 >x : Symbol(x, Decl(aliasUsageInObjectLiteral_main.ts, 5, 32))
->moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 64))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 66))
 
 var b: { x: IHasVisualizationModel } = { x: moduleA };
 >b : Symbol(b, Decl(aliasUsageInObjectLiteral_main.ts, 6, 3))
 >x : Symbol(x, Decl(aliasUsageInObjectLiteral_main.ts, 6, 8))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInObjectLiteral_main.ts, 1, 62))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInObjectLiteral_main.ts, 1, 64))
 >x : Symbol(x, Decl(aliasUsageInObjectLiteral_main.ts, 6, 40))
->moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 64))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 66))
 
 var c: { y: { z: IHasVisualizationModel } } = { y: { z: moduleA } };
 >c : Symbol(c, Decl(aliasUsageInObjectLiteral_main.ts, 7, 3))
 >y : Symbol(y, Decl(aliasUsageInObjectLiteral_main.ts, 7, 8))
 >z : Symbol(z, Decl(aliasUsageInObjectLiteral_main.ts, 7, 13))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInObjectLiteral_main.ts, 1, 62))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInObjectLiteral_main.ts, 1, 64))
 >y : Symbol(y, Decl(aliasUsageInObjectLiteral_main.ts, 7, 47))
 >z : Symbol(z, Decl(aliasUsageInObjectLiteral_main.ts, 7, 52))
->moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 64))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInObjectLiteral_main.ts, 0, 66))
 
 === tests/cases/compiler/aliasUsageInObjectLiteral_backbone.ts ===
 export class Model {
@@ -46,11 +46,11 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInObjectLiteral_moduleA.ts ===
-import Backbone = require("aliasUsageInObjectLiteral_backbone");
+import Backbone = require("./aliasUsageInObjectLiteral_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInObjectLiteral_moduleA.ts, 0, 0))
 
 export class VisualizationModel extends Backbone.Model {
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInObjectLiteral_moduleA.ts, 0, 64))
+>VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInObjectLiteral_moduleA.ts, 0, 66))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInObjectLiteral_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInObjectLiteral_moduleA.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInObjectLiteral_backbone.ts, 0, 0))

tests/baselines/reference/aliasUsageInObjectLiteral.types

@@ -1,8 +1,8 @@
 === tests/cases/compiler/aliasUsageInObjectLiteral_main.ts ===
-import Backbone = require("aliasUsageInObjectLiteral_backbone");
+import Backbone = require("./aliasUsageInObjectLiteral_backbone");
 >Backbone : typeof Backbone
 
-import moduleA = require("aliasUsageInObjectLiteral_moduleA");
+import moduleA = require("./aliasUsageInObjectLiteral_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
@@ -50,7 +50,7 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInObjectLiteral_moduleA.ts ===
-import Backbone = require("aliasUsageInObjectLiteral_backbone");
+import Backbone = require("./aliasUsageInObjectLiteral_backbone");
 >Backbone : typeof Backbone
 
 export class VisualizationModel extends Backbone.Model {

tests/baselines/reference/aliasUsageInOrExpression.js

@@ -6,14 +6,14 @@ export class Model {
 }
 
 //// [aliasUsageInOrExpression_moduleA.ts]
-import Backbone = require("aliasUsageInOrExpression_backbone");
+import Backbone = require("./aliasUsageInOrExpression_backbone");
 export class VisualizationModel extends Backbone.Model {
     // interesting stuff here
 }
 
 //// [aliasUsageInOrExpression_main.ts]
-import Backbone = require("aliasUsageInOrExpression_backbone");
-import moduleA = require("aliasUsageInOrExpression_moduleA");
+import Backbone = require("./aliasUsageInOrExpression_backbone");
+import moduleA = require("./aliasUsageInOrExpression_moduleA");
 interface IHasVisualizationModel {
     VisualizationModel: typeof Backbone.Model;
 }
@@ -37,7 +37,7 @@ var __extends = (this && this.__extends) || function (d, b) {
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
-var Backbone = require("aliasUsageInOrExpression_backbone");
+var Backbone = require("./aliasUsageInOrExpression_backbone");
 var VisualizationModel = (function (_super) {
     __extends(VisualizationModel, _super);
     function VisualizationModel() {
@@ -47,7 +47,7 @@ var VisualizationModel = (function (_super) {
 })(Backbone.Model);
 exports.VisualizationModel = VisualizationModel;
 //// [aliasUsageInOrExpression_main.js]
-var moduleA = require("aliasUsageInOrExpression_moduleA");
+var moduleA = require("./aliasUsageInOrExpression_moduleA");
 var i;
 var d1 = i || moduleA;
 var d2 = i || moduleA;

tests/baselines/reference/aliasUsageInOrExpression.symbols

@@ -1,12 +1,12 @@
 === tests/cases/compiler/aliasUsageInOrExpression_main.ts ===
-import Backbone = require("aliasUsageInOrExpression_backbone");
+import Backbone = require("./aliasUsageInOrExpression_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInOrExpression_main.ts, 0, 0))
 
-import moduleA = require("aliasUsageInOrExpression_moduleA");
->moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 63))
+import moduleA = require("./aliasUsageInOrExpression_moduleA");
+>moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 65))
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 63))
 
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 2, 34))
@@ -16,42 +16,42 @@ interface IHasVisualizationModel {
 }
 var i: IHasVisualizationModel;
 >i : Symbol(i, Decl(aliasUsageInOrExpression_main.ts, 5, 3))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 63))
 
 var d1 = i || moduleA;
 >d1 : Symbol(d1, Decl(aliasUsageInOrExpression_main.ts, 6, 3))
 >i : Symbol(i, Decl(aliasUsageInOrExpression_main.ts, 5, 3))
->moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 63))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 65))
 
 var d2: IHasVisualizationModel = i || moduleA;
 >d2 : Symbol(d2, Decl(aliasUsageInOrExpression_main.ts, 7, 3), Decl(aliasUsageInOrExpression_main.ts, 8, 3))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 63))
 >i : Symbol(i, Decl(aliasUsageInOrExpression_main.ts, 5, 3))
->moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 63))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 65))
 
 var d2: IHasVisualizationModel = moduleA || i;
 >d2 : Symbol(d2, Decl(aliasUsageInOrExpression_main.ts, 7, 3), Decl(aliasUsageInOrExpression_main.ts, 8, 3))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
->moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 63))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 63))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 65))
 >i : Symbol(i, Decl(aliasUsageInOrExpression_main.ts, 5, 3))
 
 var e: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null || { x: moduleA };
 >e : Symbol(e, Decl(aliasUsageInOrExpression_main.ts, 9, 3))
 >x : Symbol(x, Decl(aliasUsageInOrExpression_main.ts, 9, 8))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 63))
 >x : Symbol(x, Decl(aliasUsageInOrExpression_main.ts, 9, 41))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 63))
 >x : Symbol(x, Decl(aliasUsageInOrExpression_main.ts, 9, 79))
->moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 63))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 65))
 
 var f: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null ? { x: moduleA } : null;
 >f : Symbol(f, Decl(aliasUsageInOrExpression_main.ts, 10, 3))
 >x : Symbol(x, Decl(aliasUsageInOrExpression_main.ts, 10, 8))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 63))
 >x : Symbol(x, Decl(aliasUsageInOrExpression_main.ts, 10, 41))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 61))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInOrExpression_main.ts, 1, 63))
 >x : Symbol(x, Decl(aliasUsageInOrExpression_main.ts, 10, 78))
->moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 63))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInOrExpression_main.ts, 0, 65))
 
 === tests/cases/compiler/aliasUsageInOrExpression_backbone.ts ===
 export class Model {
@@ -62,11 +62,11 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInOrExpression_moduleA.ts ===
-import Backbone = require("aliasUsageInOrExpression_backbone");
+import Backbone = require("./aliasUsageInOrExpression_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInOrExpression_moduleA.ts, 0, 0))
 
 export class VisualizationModel extends Backbone.Model {
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInOrExpression_moduleA.ts, 0, 63))
+>VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInOrExpression_moduleA.ts, 0, 65))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInOrExpression_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInOrExpression_moduleA.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInOrExpression_backbone.ts, 0, 0))

tests/baselines/reference/aliasUsageInOrExpression.types

@@ -1,8 +1,8 @@
 === tests/cases/compiler/aliasUsageInOrExpression_main.ts ===
-import Backbone = require("aliasUsageInOrExpression_backbone");
+import Backbone = require("./aliasUsageInOrExpression_backbone");
 >Backbone : typeof Backbone
 
-import moduleA = require("aliasUsageInOrExpression_moduleA");
+import moduleA = require("./aliasUsageInOrExpression_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
@@ -74,7 +74,7 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInOrExpression_moduleA.ts ===
-import Backbone = require("aliasUsageInOrExpression_backbone");
+import Backbone = require("./aliasUsageInOrExpression_backbone");
 >Backbone : typeof Backbone
 
 export class VisualizationModel extends Backbone.Model {

tests/baselines/reference/aliasUsageInTypeArgumentOfExtendsClause.js

@@ -6,14 +6,14 @@ export class Model {
 }
 
 //// [aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts]
-import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
+import Backbone = require("./aliasUsageInTypeArgumentOfExtendsClause_backbone");
 export class VisualizationModel extends Backbone.Model {
     // interesting stuff here
 }
 
 //// [aliasUsageInTypeArgumentOfExtendsClause_main.ts]
-import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
-import moduleA = require("aliasUsageInTypeArgumentOfExtendsClause_moduleA");
+import Backbone = require("./aliasUsageInTypeArgumentOfExtendsClause_backbone");
+import moduleA = require("./aliasUsageInTypeArgumentOfExtendsClause_moduleA");
 interface IHasVisualizationModel {
     VisualizationModel: typeof Backbone.Model;
 }
@@ -37,7 +37,7 @@ var __extends = (this && this.__extends) || function (d, b) {
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
-var Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
+var Backbone = require("./aliasUsageInTypeArgumentOfExtendsClause_backbone");
 var VisualizationModel = (function (_super) {
     __extends(VisualizationModel, _super);
     function VisualizationModel() {
@@ -52,7 +52,7 @@ var __extends = (this && this.__extends) || function (d, b) {
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
-var moduleA = require("aliasUsageInTypeArgumentOfExtendsClause_moduleA");
+var moduleA = require("./aliasUsageInTypeArgumentOfExtendsClause_moduleA");
 var C = (function () {
     function C() {
     }

tests/baselines/reference/aliasUsageInTypeArgumentOfExtendsClause.symbols

@@ -1,12 +1,12 @@
 === tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_main.ts ===
-import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
+import Backbone = require("./aliasUsageInTypeArgumentOfExtendsClause_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 0, 0))
 
-import moduleA = require("aliasUsageInTypeArgumentOfExtendsClause_moduleA");
->moduleA : Symbol(moduleA, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 0, 78))
+import moduleA = require("./aliasUsageInTypeArgumentOfExtendsClause_moduleA");
+>moduleA : Symbol(moduleA, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 0, 80))
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 1, 76))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 1, 78))
 
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 2, 34))
@@ -17,7 +17,7 @@ interface IHasVisualizationModel {
 class C<T extends IHasVisualizationModel> {
 >C : Symbol(C, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 4, 1))
 >T : Symbol(T, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 5, 8))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 1, 76))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 1, 78))
 
     x: T;
 >x : Symbol(x, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 5, 43))
@@ -26,11 +26,11 @@ class C<T extends IHasVisualizationModel> {
 class D extends C<IHasVisualizationModel> {
 >D : Symbol(D, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 7, 1))
 >C : Symbol(C, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 4, 1))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 1, 76))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 1, 78))
 
     x = moduleA;
 >x : Symbol(x, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 8, 43))
->moduleA : Symbol(moduleA, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 0, 78))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts, 0, 80))
 }
 === tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone.ts ===
 export class Model {
@@ -41,11 +41,11 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts ===
-import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
+import Backbone = require("./aliasUsageInTypeArgumentOfExtendsClause_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts, 0, 0))
 
 export class VisualizationModel extends Backbone.Model {
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts, 0, 78))
+>VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts, 0, 80))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInTypeArgumentOfExtendsClause_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInTypeArgumentOfExtendsClause_backbone.ts, 0, 0))

tests/baselines/reference/aliasUsageInTypeArgumentOfExtendsClause.types

@@ -1,8 +1,8 @@
 === tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_main.ts ===
-import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
+import Backbone = require("./aliasUsageInTypeArgumentOfExtendsClause_backbone");
 >Backbone : typeof Backbone
 
-import moduleA = require("aliasUsageInTypeArgumentOfExtendsClause_moduleA");
+import moduleA = require("./aliasUsageInTypeArgumentOfExtendsClause_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
@@ -41,7 +41,7 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts ===
-import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
+import Backbone = require("./aliasUsageInTypeArgumentOfExtendsClause_backbone");
 >Backbone : typeof Backbone
 
 export class VisualizationModel extends Backbone.Model {

tests/baselines/reference/aliasUsageInVarAssignment.js

@@ -6,14 +6,14 @@ export class Model {
 }
 
 //// [aliasUsageInVarAssignment_moduleA.ts]
-import Backbone = require("aliasUsageInVarAssignment_backbone");
+import Backbone = require("./aliasUsageInVarAssignment_backbone");
 export class VisualizationModel extends Backbone.Model {
     // interesting stuff here
 }
 
 //// [aliasUsageInVarAssignment_main.ts]
-import Backbone = require("aliasUsageInVarAssignment_backbone");
-import moduleA = require("aliasUsageInVarAssignment_moduleA");
+import Backbone = require("./aliasUsageInVarAssignment_backbone");
+import moduleA = require("./aliasUsageInVarAssignment_moduleA");
 interface IHasVisualizationModel {
     VisualizationModel: typeof Backbone.Model;
 }
@@ -33,7 +33,7 @@ var __extends = (this && this.__extends) || function (d, b) {
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
-var Backbone = require("aliasUsageInVarAssignment_backbone");
+var Backbone = require("./aliasUsageInVarAssignment_backbone");
 var VisualizationModel = (function (_super) {
     __extends(VisualizationModel, _super);
     function VisualizationModel() {

tests/baselines/reference/aliasUsageInVarAssignment.symbols

@@ -1,12 +1,12 @@
 === tests/cases/compiler/aliasUsageInVarAssignment_main.ts ===
-import Backbone = require("aliasUsageInVarAssignment_backbone");
+import Backbone = require("./aliasUsageInVarAssignment_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInVarAssignment_main.ts, 0, 0))
 
-import moduleA = require("aliasUsageInVarAssignment_moduleA");
->moduleA : Symbol(moduleA, Decl(aliasUsageInVarAssignment_main.ts, 0, 64))
+import moduleA = require("./aliasUsageInVarAssignment_moduleA");
+>moduleA : Symbol(moduleA, Decl(aliasUsageInVarAssignment_main.ts, 0, 66))
 
 interface IHasVisualizationModel {
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInVarAssignment_main.ts, 1, 62))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInVarAssignment_main.ts, 1, 64))
 
     VisualizationModel: typeof Backbone.Model;
 >VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInVarAssignment_main.ts, 2, 34))
@@ -16,11 +16,11 @@ interface IHasVisualizationModel {
 }
 var i: IHasVisualizationModel;
 >i : Symbol(i, Decl(aliasUsageInVarAssignment_main.ts, 5, 3))
->IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInVarAssignment_main.ts, 1, 62))
+>IHasVisualizationModel : Symbol(IHasVisualizationModel, Decl(aliasUsageInVarAssignment_main.ts, 1, 64))
 
 var m: typeof moduleA = i;
 >m : Symbol(m, Decl(aliasUsageInVarAssignment_main.ts, 6, 3))
->moduleA : Symbol(moduleA, Decl(aliasUsageInVarAssignment_main.ts, 0, 64))
+>moduleA : Symbol(moduleA, Decl(aliasUsageInVarAssignment_main.ts, 0, 66))
 >i : Symbol(i, Decl(aliasUsageInVarAssignment_main.ts, 5, 3))
 
 === tests/cases/compiler/aliasUsageInVarAssignment_backbone.ts ===
@@ -32,11 +32,11 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInVarAssignment_moduleA.ts ===
-import Backbone = require("aliasUsageInVarAssignment_backbone");
+import Backbone = require("./aliasUsageInVarAssignment_backbone");
 >Backbone : Symbol(Backbone, Decl(aliasUsageInVarAssignment_moduleA.ts, 0, 0))
 
 export class VisualizationModel extends Backbone.Model {
->VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInVarAssignment_moduleA.ts, 0, 64))
+>VisualizationModel : Symbol(VisualizationModel, Decl(aliasUsageInVarAssignment_moduleA.ts, 0, 66))
 >Backbone.Model : Symbol(Backbone.Model, Decl(aliasUsageInVarAssignment_backbone.ts, 0, 0))
 >Backbone : Symbol(Backbone, Decl(aliasUsageInVarAssignment_moduleA.ts, 0, 0))
 >Model : Symbol(Backbone.Model, Decl(aliasUsageInVarAssignment_backbone.ts, 0, 0))

tests/baselines/reference/aliasUsageInVarAssignment.types

@@ -1,8 +1,8 @@
 === tests/cases/compiler/aliasUsageInVarAssignment_main.ts ===
-import Backbone = require("aliasUsageInVarAssignment_backbone");
+import Backbone = require("./aliasUsageInVarAssignment_backbone");
 >Backbone : typeof Backbone
 
-import moduleA = require("aliasUsageInVarAssignment_moduleA");
+import moduleA = require("./aliasUsageInVarAssignment_moduleA");
 >moduleA : typeof moduleA
 
 interface IHasVisualizationModel {
@@ -32,7 +32,7 @@ export class Model {
 }
 
 === tests/cases/compiler/aliasUsageInVarAssignment_moduleA.ts ===
-import Backbone = require("aliasUsageInVarAssignment_backbone");
+import Backbone = require("./aliasUsageInVarAssignment_backbone");
 >Backbone : typeof Backbone
 
 export class VisualizationModel extends Backbone.Model {

tests/baselines/reference/aliasUsedAsNameValue.js

@@ -9,8 +9,8 @@ export function b(a: any): any { return null; }
 //// [aliasUsedAsNameValue_2.ts]
 ///<reference path='aliasUsedAsNameValue_0.ts' />
 ///<reference path='aliasUsedAsNameValue_1.ts' />
-import mod = require("aliasUsedAsNameValue_0");
-import b = require("aliasUsedAsNameValue_1");
+import mod = require("./aliasUsedAsNameValue_0");
+import b = require("./aliasUsedAsNameValue_1");
  
 export var a = function () {
     //var x = mod.id; // TODO needed hack that mod is loaded
@@ -25,8 +25,8 @@ exports.b = b;
 //// [aliasUsedAsNameValue_2.js]
 ///<reference path='aliasUsedAsNameValue_0.ts' />
 ///<reference path='aliasUsedAsNameValue_1.ts' />
-var mod = require("aliasUsedAsNameValue_0");
-var b = require("aliasUsedAsNameValue_1");
+var mod = require("./aliasUsedAsNameValue_0");
+var b = require("./aliasUsedAsNameValue_1");
 exports.a = function () {
     //var x = mod.id; // TODO needed hack that mod is loaded
     b.b(mod);

tests/baselines/reference/aliasUsedAsNameValue.symbols

@@ -1,11 +1,11 @@
 === tests/cases/compiler/aliasUsedAsNameValue_2.ts ===
 ///<reference path='aliasUsedAsNameValue_0.ts' />
 ///<reference path='aliasUsedAsNameValue_1.ts' />
-import mod = require("aliasUsedAsNameValue_0");
+import mod = require("./aliasUsedAsNameValue_0");
 >mod : Symbol(mod, Decl(aliasUsedAsNameValue_2.ts, 0, 0))
 
-import b = require("aliasUsedAsNameValue_1");
->b : Symbol(b, Decl(aliasUsedAsNameValue_2.ts, 2, 47))
+import b = require("./aliasUsedAsNameValue_1");
+>b : Symbol(b, Decl(aliasUsedAsNameValue_2.ts, 2, 49))
  
 export var a = function () {
 >a : Symbol(a, Decl(aliasUsedAsNameValue_2.ts, 5, 10))
@@ -13,7 +13,7 @@ export var a = function () {
     //var x = mod.id; // TODO needed hack that mod is loaded
     b.b(mod);
 >b.b : Symbol(b.b, Decl(aliasUsedAsNameValue_1.ts, 0, 0))
->b : Symbol(b, Decl(aliasUsedAsNameValue_2.ts, 2, 47))
+>b : Symbol(b, Decl(aliasUsedAsNameValue_2.ts, 2, 49))
 >b : Symbol(b.b, Decl(aliasUsedAsNameValue_1.ts, 0, 0))
 >mod : Symbol(mod, Decl(aliasUsedAsNameValue_2.ts, 0, 0))
 }

tests/baselines/reference/aliasUsedAsNameValue.types

@@ -1,10 +1,10 @@
 === tests/cases/compiler/aliasUsedAsNameValue_2.ts ===
 ///<reference path='aliasUsedAsNameValue_0.ts' />
 ///<reference path='aliasUsedAsNameValue_1.ts' />
-import mod = require("aliasUsedAsNameValue_0");
+import mod = require("./aliasUsedAsNameValue_0");
 >mod : typeof mod
 
-import b = require("aliasUsedAsNameValue_1");
+import b = require("./aliasUsedAsNameValue_1");
 >b : typeof b
  
 export var a = function () {

tests/baselines/reference/aliasWithInterfaceExportAssignmentUsedInVarInitializer.errors.txt

@@ -2,7 +2,7 @@ tests/cases/compiler/aliasWithInterfaceExportAssignmentUsedInVarInitializer_1.ts
 
 
 ==== tests/cases/compiler/aliasWithInterfaceExportAssignmentUsedInVarInitializer_1.ts (1 errors) ====
-    import moduleA = require("aliasWithInterfaceExportAssignmentUsedInVarInitializer_0");
+    import moduleA = require("./aliasWithInterfaceExportAssignmentUsedInVarInitializer_0");
     var d = b.q3;
             ~
 !!! error TS2304: Cannot find name 'b'.

tests/baselines/reference/aliasWithInterfaceExportAssignmentUsedInVarInitializer.js

@@ -7,7 +7,7 @@ interface c {
 export = c;
 
 //// [aliasWithInterfaceExportAssignmentUsedInVarInitializer_1.ts]
-import moduleA = require("aliasWithInterfaceExportAssignmentUsedInVarInitializer_0");
+import moduleA = require("./aliasWithInterfaceExportAssignmentUsedInVarInitializer_0");
 var d = b.q3;
 
 //// [aliasWithInterfaceExportAssignmentUsedInVarInitializer_0.js]

tests/baselines/reference/arrayOfExportedClass.js

@@ -9,7 +9,7 @@ export = Car;
 
 //// [arrayOfExportedClass_1.ts]
 ///<reference path='arrayOfExportedClass_0.ts'/>
-import Car = require('arrayOfExportedClass_0');
+import Car = require('./arrayOfExportedClass_0');
 
 class Road {
 

tests/baselines/reference/arrayOfExportedClass.symbols

@@ -1,10 +1,10 @@
 === tests/cases/compiler/arrayOfExportedClass_1.ts ===
 ///<reference path='arrayOfExportedClass_0.ts'/>
-import Car = require('arrayOfExportedClass_0');
+import Car = require('./arrayOfExportedClass_0');
 >Car : Symbol(Car, Decl(arrayOfExportedClass_1.ts, 0, 0))
 
 class Road {
->Road : Symbol(Road, Decl(arrayOfExportedClass_1.ts, 1, 47))
+>Road : Symbol(Road, Decl(arrayOfExportedClass_1.ts, 1, 49))
 
     public cars: Car[];
 >cars : Symbol(cars, Decl(arrayOfExportedClass_1.ts, 3, 12))
@@ -17,14 +17,14 @@ class Road {
 
         this.cars = cars;
 >this.cars : Symbol(cars, Decl(arrayOfExportedClass_1.ts, 3, 12))
->this : Symbol(Road, Decl(arrayOfExportedClass_1.ts, 1, 47))
+>this : Symbol(Road, Decl(arrayOfExportedClass_1.ts, 1, 49))
 >cars : Symbol(cars, Decl(arrayOfExportedClass_1.ts, 3, 12))
 >cars : Symbol(cars, Decl(arrayOfExportedClass_1.ts, 7, 19))
     }
 }
 
 export = Road;
->Road : Symbol(Road, Decl(arrayOfExportedClass_1.ts, 1, 47))
+>Road : Symbol(Road, Decl(arrayOfExportedClass_1.ts, 1, 49))
 
 === tests/cases/compiler/arrayOfExportedClass_0.ts ===
 class Car {

tests/baselines/reference/arrayOfExportedClass.types

@@ -1,6 +1,6 @@
 === tests/cases/compiler/arrayOfExportedClass_1.ts ===
 ///<reference path='arrayOfExportedClass_0.ts'/>
-import Car = require('arrayOfExportedClass_0');
+import Car = require('./arrayOfExportedClass_0');
 >Car : typeof Car
 
 class Road {

tests/baselines/reference/chainedImportAlias.js

@@ -6,7 +6,7 @@ export module m {
 }
 
 //// [chainedImportAlias_file1.ts]
-import x = require('chainedImportAlias_file0');
+import x = require('./chainedImportAlias_file0');
 import y = x;
 y.m.foo();
 
@@ -18,6 +18,6 @@ var m;
     m.foo = foo;
 })(m = exports.m || (exports.m = {}));
 //// [chainedImportAlias_file1.js]
-var x = require('chainedImportAlias_file0');
+var x = require('./chainedImportAlias_file0');
 var y = x;
 y.m.foo();

tests/baselines/reference/chainedImportAlias.symbols

@@ -1,15 +1,15 @@
 === tests/cases/compiler/chainedImportAlias_file1.ts ===
-import x = require('chainedImportAlias_file0');
+import x = require('./chainedImportAlias_file0');
 >x : Symbol(x, Decl(chainedImportAlias_file1.ts, 0, 0))
 
 import y = x;
->y : Symbol(y, Decl(chainedImportAlias_file1.ts, 0, 47))
+>y : Symbol(y, Decl(chainedImportAlias_file1.ts, 0, 49))
 >x : Symbol(x, Decl(chainedImportAlias_file0.ts, 0, 0))
 
 y.m.foo();
 >y.m.foo : Symbol(x.m.foo, Decl(chainedImportAlias_file0.ts, 0, 17))
 >y.m : Symbol(x.m, Decl(chainedImportAlias_file0.ts, 0, 0))
->y : Symbol(y, Decl(chainedImportAlias_file1.ts, 0, 47))
+>y : Symbol(y, Decl(chainedImportAlias_file1.ts, 0, 49))
 >m : Symbol(x.m, Decl(chainedImportAlias_file0.ts, 0, 0))
 >foo : Symbol(x.m.foo, Decl(chainedImportAlias_file0.ts, 0, 17))
 

tests/baselines/reference/chainedImportAlias.types

@@ -1,5 +1,5 @@
 === tests/cases/compiler/chainedImportAlias_file1.ts ===
-import x = require('chainedImportAlias_file0');
+import x = require('./chainedImportAlias_file0');
 >x : typeof x
 
 import y = x;

tests/baselines/reference/commentsExternalModules3.js

@@ -54,7 +54,7 @@ var myvar2 = new m4.m2.c();
 
 //// [commentsExternalModules_1.ts]
 /**This is on import declaration*/
-import extMod = require("commentsExternalModules2_0"); // trailing comment 1
+import extMod = require("./commentsExternalModules2_0"); // trailing comment 1
 extMod.m1.fooExport();
 export var newVar = new extMod.m1.m2.c();
 extMod.m4.fooExport();
@@ -124,7 +124,7 @@ m4.fooExport();
 var myvar2 = new m4.m2.c();
 //// [commentsExternalModules_1.js]
 /**This is on import declaration*/
-var extMod = require("commentsExternalModules2_0"); // trailing comment 1
+var extMod = require("./commentsExternalModules2_0"); // trailing comment 1
 extMod.m1.fooExport();
 exports.newVar = new extMod.m1.m2.c();
 extMod.m4.fooExport();
@@ -165,6 +165,6 @@ export declare module m4 {
 }
 //// [commentsExternalModules_1.d.ts]
 /**This is on import declaration*/
-import extMod = require("commentsExternalModules2_0");
+import extMod = require("./commentsExternalModules2_0");
 export declare var newVar: extMod.m1.m2.c;
 export declare var newVar2: extMod.m4.m2.c;

tests/baselines/reference/commentsExternalModules3.symbols

@@ -1,6 +1,6 @@
 === tests/cases/compiler/commentsExternalModules_1.ts ===
 /**This is on import declaration*/
-import extMod = require("commentsExternalModules2_0"); // trailing comment 1
+import extMod = require("./commentsExternalModules2_0"); // trailing comment 1
 >extMod : Symbol(extMod, Decl(commentsExternalModules_1.ts, 0, 0))
 
 extMod.m1.fooExport();

tests/baselines/reference/commentsExternalModules3.types

@@ -1,6 +1,6 @@
 === tests/cases/compiler/commentsExternalModules_1.ts ===
 /**This is on import declaration*/
-import extMod = require("commentsExternalModules2_0"); // trailing comment 1
+import extMod = require("./commentsExternalModules2_0"); // trailing comment 1
 >extMod : typeof extMod
 
 extMod.m1.fooExport();

tests/baselines/reference/declFileAliasUseBeforeDeclaration.js

@@ -6,7 +6,7 @@ export class Foo { }
 
 //// [declFileAliasUseBeforeDeclaration_test.ts]
 export function bar(a: foo.Foo) { }
-import foo = require("declFileAliasUseBeforeDeclaration_foo");
+import foo = require("./declFileAliasUseBeforeDeclaration_foo");
 
 //// [declFileAliasUseBeforeDeclaration_foo.js]
 var Foo = (function () {
@@ -25,4 +25,4 @@ export declare class Foo {
 }
 //// [declFileAliasUseBeforeDeclaration_test.d.ts]
 export declare function bar(a: foo.Foo): void;
-import foo = require("declFileAliasUseBeforeDeclaration_foo");
+import foo = require("./declFileAliasUseBeforeDeclaration_foo");

tests/baselines/reference/declFileAliasUseBeforeDeclaration.symbols

@@ -5,7 +5,7 @@ export function bar(a: foo.Foo) { }
 >foo : Symbol(foo, Decl(declFileAliasUseBeforeDeclaration_test.ts, 0, 35))
 >Foo : Symbol(foo.Foo, Decl(declFileAliasUseBeforeDeclaration_foo.ts, 0, 0))
 
-import foo = require("declFileAliasUseBeforeDeclaration_foo");
+import foo = require("./declFileAliasUseBeforeDeclaration_foo");
 >foo : Symbol(foo, Decl(declFileAliasUseBeforeDeclaration_test.ts, 0, 35))
 
 === tests/cases/compiler/declFileAliasUseBeforeDeclaration_foo.ts ===

tests/baselines/reference/declFileAliasUseBeforeDeclaration.types

@@ -5,7 +5,7 @@ export function bar(a: foo.Foo) { }
 >foo : any
 >Foo : foo.Foo
 
-import foo = require("declFileAliasUseBeforeDeclaration_foo");
+import foo = require("./declFileAliasUseBeforeDeclaration_foo");
 >foo : typeof foo
 
 === tests/cases/compiler/declFileAliasUseBeforeDeclaration_foo.ts ===

tests/baselines/reference/declFileForExportedImport.js

@@ -5,7 +5,7 @@ export var x: number;
 
 //// [declFileForExportedImport_1.ts]
 ///<reference path='declFileForExportedImport_0.ts'/>
-export import a = require('declFileForExportedImport_0');
+export import a = require('./declFileForExportedImport_0');
 var y = a.x;
 
 export import b = a;
@@ -14,7 +14,7 @@ var z = b.x;
 //// [declFileForExportedImport_0.js]
 //// [declFileForExportedImport_1.js]
 ///<reference path='declFileForExportedImport_0.ts'/>
-exports.a = require('declFileForExportedImport_0');
+exports.a = require('./declFileForExportedImport_0');
 var y = exports.a.x;
 exports.b = exports.a;
 var z = exports.b.x;
@@ -24,5 +24,5 @@ var z = exports.b.x;
 export declare var x: number;
 //// [declFileForExportedImport_1.d.ts]
 /// <reference path="declFileForExportedImport_0.d.ts" />
-export import a = require('declFileForExportedImport_0');
+export import a = require('./declFileForExportedImport_0');
 export import b = a;

tests/baselines/reference/declFileForExportedImport.symbols

@@ -1,6 +1,6 @@
 === tests/cases/compiler/declFileForExportedImport_1.ts ===
 ///<reference path='declFileForExportedImport_0.ts'/>
-export import a = require('declFileForExportedImport_0');
+export import a = require('./declFileForExportedImport_0');
 >a : Symbol(a, Decl(declFileForExportedImport_1.ts, 0, 0))
 
 var y = a.x;

tests/baselines/reference/declFileForExportedImport.types

@@ -1,6 +1,6 @@
 === tests/cases/compiler/declFileForExportedImport_1.ts ===
 ///<reference path='declFileForExportedImport_0.ts'/>
-export import a = require('declFileForExportedImport_0');
+export import a = require('./declFileForExportedImport_0');
 >a : typeof a
 
 var y = a.x;

tests/baselines/reference/declFileImportModuleWithExportAssignment.js

@@ -21,7 +21,7 @@ export = m2;
 
 //// [declFileImportModuleWithExportAssignment_1.ts]
 /**This is on import declaration*/
-import a1 = require("declFileImportModuleWithExportAssignment_0");
+import a1 = require("./declFileImportModuleWithExportAssignment_0");
 export var a = a1;
 a.test1(null, null, null);
 
@@ -31,7 +31,7 @@ var m2;
 module.exports = m2;
 //// [declFileImportModuleWithExportAssignment_1.js]
 /**This is on import declaration*/
-var a1 = require("declFileImportModuleWithExportAssignment_0");
+var a1 = require("./declFileImportModuleWithExportAssignment_0");
 exports.a = a1;
 exports.a.test1(null, null, null);
 
@@ -54,7 +54,7 @@ declare var m2: {
 export = m2;
 //// [declFileImportModuleWithExportAssignment_1.d.ts]
 /**This is on import declaration*/
-import a1 = require("declFileImportModuleWithExportAssignment_0");
+import a1 = require("./declFileImportModuleWithExportAssignment_0");
 export declare var a: {
     (): a1.connectExport;
     test1: a1.connectModule;

tests/baselines/reference/declFileImportModuleWithExportAssignment.symbols

@@ -1,6 +1,6 @@
 === tests/cases/compiler/declFileImportModuleWithExportAssignment_1.ts ===
 /**This is on import declaration*/
-import a1 = require("declFileImportModuleWithExportAssignment_0");
+import a1 = require("./declFileImportModuleWithExportAssignment_0");
 >a1 : Symbol(a1, Decl(declFileImportModuleWithExportAssignment_1.ts, 0, 0))
 
 export var a = a1;

tests/baselines/reference/declFileImportModuleWithExportAssignment.types

@@ -1,6 +1,6 @@
 === tests/cases/compiler/declFileImportModuleWithExportAssignment_1.ts ===
 /**This is on import declaration*/
-import a1 = require("declFileImportModuleWithExportAssignment_0");
+import a1 = require("./declFileImportModuleWithExportAssignment_0");
 >a1 : { (): a1.connectExport; test1: a1.connectModule; test2(): a1.connectModule; }
 
 export var a = a1;

tests/baselines/reference/declarationEmit_exportAssignment.js

@@ -7,7 +7,7 @@ export function bar() { }
 export interface Buzz { }
 
 //// [index.ts]
-import {foo} from "utils";
+import {foo} from "./utils";
 export = foo;
 
 //// [utils.js]
@@ -16,7 +16,7 @@ exports.foo = foo;
 function bar() { }
 exports.bar = bar;
 //// [index.js]
-var utils_1 = require("utils");
+var utils_1 = require("./utils");
 module.exports = utils_1.foo;
 
 
@@ -26,5 +26,5 @@ export declare function bar(): void;
 export interface Buzz {
 }
 //// [index.d.ts]
-import { foo } from "utils";
+import { foo } from "./utils";
 export = foo;

tests/baselines/reference/declarationEmit_exportAssignment.symbols

@@ -10,7 +10,7 @@ export interface Buzz { }
 >Buzz : Symbol(Buzz, Decl(utils.ts, 2, 25))
 
 === tests/cases/compiler/index.ts ===
-import {foo} from "utils";
+import {foo} from "./utils";
 >foo : Symbol(foo, Decl(index.ts, 0, 8))
 
 export = foo;

tests/baselines/reference/declarationEmit_exportAssignment.types

@@ -10,7 +10,7 @@ export interface Buzz { }
 >Buzz : Buzz
 
 === tests/cases/compiler/index.ts ===
-import {foo} from "utils";
+import {foo} from "./utils";
 >foo : () => void
 
 export = foo;

tests/baselines/reference/declarationEmit_exportDeclaration.js

@@ -7,7 +7,7 @@ export function bar() { }
 export interface Buzz { }
 
 //// [index.ts]
-import {foo, bar, Buzz} from "utils";
+import {foo, bar, Buzz} from "./utils";
 
 foo();
 let obj: Buzz;
@@ -19,7 +19,7 @@ exports.foo = foo;
 function bar() { }
 exports.bar = bar;
 //// [index.js]
-var utils_1 = require("utils");
+var utils_1 = require("./utils");
 exports.bar = utils_1.bar;
 utils_1.foo();
 var obj;
@@ -31,5 +31,5 @@ export declare function bar(): void;
 export interface Buzz {
 }
 //// [index.d.ts]
-import { bar } from "utils";
+import { bar } from "./utils";
 export { bar };

tests/baselines/reference/declarationEmit_exportDeclaration.symbols

@@ -10,7 +10,7 @@ export interface Buzz { }
 >Buzz : Symbol(Buzz, Decl(utils.ts, 2, 25))
 
 === tests/cases/compiler/index.ts ===
-import {foo, bar, Buzz} from "utils";
+import {foo, bar, Buzz} from "./utils";
 >foo : Symbol(foo, Decl(index.ts, 0, 8))
 >bar : Symbol(bar, Decl(index.ts, 0, 12))
 >Buzz : Symbol(Buzz, Decl(index.ts, 0, 17))

tests/baselines/reference/declarationEmit_exportDeclaration.types

@@ -10,7 +10,7 @@ export interface Buzz { }
 >Buzz : Buzz
 
 === tests/cases/compiler/index.ts ===
-import {foo, bar, Buzz} from "utils";
+import {foo, bar, Buzz} from "./utils";
 >foo : () => void
 >bar : () => void
 >Buzz : any

tests/baselines/reference/declarationEmit_nameConflicts.js

@@ -5,7 +5,7 @@ module f { export class c { } }
 export = f;
 
 //// [declarationEmit_nameConflicts_0.ts]
-import im = require('declarationEmit_nameConflicts_1');
+import im = require('./declarationEmit_nameConflicts_1');
 export module M {
     export function f() { }
     export class C { }
@@ -61,7 +61,7 @@ var f;
 })(f || (f = {}));
 module.exports = f;
 //// [declarationEmit_nameConflicts_0.js]
-var im = require('declarationEmit_nameConflicts_1');
+var im = require('./declarationEmit_nameConflicts_1');
 var M;
 (function (M) {
     function f() { }
@@ -138,7 +138,7 @@ declare module f {
 }
 export = f;
 //// [declarationEmit_nameConflicts_0.d.ts]
-import im = require('declarationEmit_nameConflicts_1');
+import im = require('./declarationEmit_nameConflicts_1');
 export declare module M {
     function f(): void;
     class C {

tests/baselines/reference/declarationEmit_nameConflicts.symbols

@@ -1,9 +1,9 @@
 === tests/cases/compiler/declarationEmit_nameConflicts_0.ts ===
-import im = require('declarationEmit_nameConflicts_1');
+import im = require('./declarationEmit_nameConflicts_1');
 >im : Symbol(im, Decl(declarationEmit_nameConflicts_0.ts, 0, 0))
 
 export module M {
->M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 55), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
+>M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 57), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
 
     export function f() { }
 >f : Symbol(f, Decl(declarationEmit_nameConflicts_0.ts, 1, 17))
@@ -23,12 +23,12 @@ export module M {
 
     export import a = M.f;
 >a : Symbol(a, Decl(declarationEmit_nameConflicts_0.ts, 7, 5))
->M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 55), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
+>M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 57), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
 >f : Symbol(f, Decl(declarationEmit_nameConflicts_0.ts, 1, 17))
 
     export import b = M.C;
 >b : Symbol(b, Decl(declarationEmit_nameConflicts_0.ts, 9, 26))
->M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 55), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
+>M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 57), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
 >C : Symbol(C, Decl(declarationEmit_nameConflicts_0.ts, 2, 27))
 
     export import c = N;
@@ -41,7 +41,7 @@ export module M {
 }
 
 export module M.P {
->M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 55), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
+>M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 57), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
 >P : Symbol(P, Decl(declarationEmit_nameConflicts_0.ts, 15, 16))
 
     export function f() { }
@@ -61,45 +61,45 @@ export module M.P {
     }
     export import im = M.P.f;
 >im : Symbol(im, Decl(declarationEmit_nameConflicts_0.ts, 21, 5))
->M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 55), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
+>M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 57), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
 >P : Symbol(P, Decl(declarationEmit_nameConflicts_0.ts, 15, 16))
 >f : Symbol(f, Decl(declarationEmit_nameConflicts_0.ts, 15, 19))
 
     export var a = M.a; // emitted incorrectly as typeof f
 >a : Symbol(a, Decl(declarationEmit_nameConflicts_0.ts, 23, 14))
 >M.a : Symbol(a, Decl(declarationEmit_nameConflicts_0.ts, 7, 5))
->M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 55), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
+>M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 57), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
 >a : Symbol(a, Decl(declarationEmit_nameConflicts_0.ts, 7, 5))
 
     export var b = M.b; // ok
 >b : Symbol(b, Decl(declarationEmit_nameConflicts_0.ts, 24, 14))
 >M.b : Symbol(b, Decl(declarationEmit_nameConflicts_0.ts, 9, 26))
->M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 55), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
+>M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 57), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
 >b : Symbol(b, Decl(declarationEmit_nameConflicts_0.ts, 9, 26))
 
     export var c = M.c; // ok
 >c : Symbol(c, Decl(declarationEmit_nameConflicts_0.ts, 25, 14))
 >M.c : Symbol(c, Decl(declarationEmit_nameConflicts_0.ts, 10, 26))
->M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 55), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
+>M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 57), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
 >c : Symbol(c, Decl(declarationEmit_nameConflicts_0.ts, 10, 26))
 
     export var g = M.c.g; // ok
 >g : Symbol(g, Decl(declarationEmit_nameConflicts_0.ts, 26, 14))
 >M.c.g : Symbol(c.g, Decl(declarationEmit_nameConflicts_0.ts, 4, 21))
 >M.c : Symbol(c, Decl(declarationEmit_nameConflicts_0.ts, 10, 26))
->M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 55), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
+>M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 57), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
 >c : Symbol(c, Decl(declarationEmit_nameConflicts_0.ts, 10, 26))
 >g : Symbol(c.g, Decl(declarationEmit_nameConflicts_0.ts, 4, 21))
 
     export var d = M.d; // emitted incorrectly as typeof im
 >d : Symbol(d, Decl(declarationEmit_nameConflicts_0.ts, 27, 14))
 >M.d : Symbol(d, Decl(declarationEmit_nameConflicts_0.ts, 11, 24))
->M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 55), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
+>M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 57), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
 >d : Symbol(d, Decl(declarationEmit_nameConflicts_0.ts, 11, 24))
 }
 
 export module M.Q {
->M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 55), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
+>M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 57), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
 >Q : Symbol(Q, Decl(declarationEmit_nameConflicts_0.ts, 30, 16))
 
     export function f() { }
@@ -120,14 +120,14 @@ export module M.Q {
     export interface b extends M.b { } // ok
 >b : Symbol(b, Decl(declarationEmit_nameConflicts_0.ts, 36, 5))
 >M.b : Symbol(b, Decl(declarationEmit_nameConflicts_0.ts, 9, 26))
->M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 55), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
+>M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 57), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
 >b : Symbol(b, Decl(declarationEmit_nameConflicts_0.ts, 9, 26))
 
     export interface I extends M.c.I { } // ok
 >I : Symbol(I, Decl(declarationEmit_nameConflicts_0.ts, 37, 38))
 >M.c.I : Symbol(M.c.I, Decl(declarationEmit_nameConflicts_0.ts, 5, 32))
 >M.c : Symbol(c, Decl(declarationEmit_nameConflicts_0.ts, 10, 26))
->M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 55), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
+>M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 57), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
 >c : Symbol(c, Decl(declarationEmit_nameConflicts_0.ts, 10, 26))
 >I : Symbol(M.c.I, Decl(declarationEmit_nameConflicts_0.ts, 5, 32))
 
@@ -138,7 +138,7 @@ export module M.Q {
 >I : Symbol(I, Decl(declarationEmit_nameConflicts_0.ts, 39, 21))
 >M.c.I : Symbol(M.c.I, Decl(declarationEmit_nameConflicts_0.ts, 5, 32))
 >M.c : Symbol(c, Decl(declarationEmit_nameConflicts_0.ts, 10, 26))
->M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 55), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
+>M : Symbol(M, Decl(declarationEmit_nameConflicts_0.ts, 0, 57), Decl(declarationEmit_nameConflicts_0.ts, 13, 1), Decl(declarationEmit_nameConflicts_0.ts, 28, 1))
 >c : Symbol(c, Decl(declarationEmit_nameConflicts_0.ts, 10, 26))
 >I : Symbol(M.c.I, Decl(declarationEmit_nameConflicts_0.ts, 5, 32))
     }

tests/baselines/reference/declarationEmit_nameConflicts.types

@@ -1,5 +1,5 @@
 === tests/cases/compiler/declarationEmit_nameConflicts_0.ts ===
-import im = require('declarationEmit_nameConflicts_1');
+import im = require('./declarationEmit_nameConflicts_1');
 >im : typeof im
 
 export module M {

tests/baselines/reference/defaultExportsCannotMerge01.errors.txt

@@ -1,9 +1,6 @@
 tests/cases/conformance/es6/modules/m1.ts(2,25): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead.
 tests/cases/conformance/es6/modules/m1.ts(11,18): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead.
-tests/cases/conformance/es6/modules/m2.ts(5,8): error TS2304: Cannot find name 'Entity'.
-tests/cases/conformance/es6/modules/m2.ts(6,8): error TS2503: Cannot find namespace 'Entity'.
-tests/cases/conformance/es6/modules/m2.ts(8,8): error TS2339: Property 'x' does not exist on type '() => number'.
-tests/cases/conformance/es6/modules/m2.ts(9,8): error TS2339: Property 'y' does not exist on type '() => number'.
+tests/cases/conformance/es6/modules/m2.ts(1,20): error TS2307: Cannot find module 'm1'.
 
 
 ==== tests/cases/conformance/es6/modules/m1.ts (2 errors) ====
@@ -29,21 +26,15 @@ tests/cases/conformance/es6/modules/m2.ts(9,8): error TS2339: Property 'y' does
         }
     }
     
-==== tests/cases/conformance/es6/modules/m2.ts (4 errors) ====
+==== tests/cases/conformance/es6/modules/m2.ts (1 errors) ====
     import Entity from "m1"
+                       ~~~~
+!!! error TS2307: Cannot find module 'm1'.
     
     Entity();
     
     var x: Entity;
-           ~~~~~~
-!!! error TS2304: Cannot find name 'Entity'.
     var y: Entity.I;
-           ~~~~~~
-!!! error TS2503: Cannot find namespace 'Entity'.
     
     Entity.x;
-           ~
-!!! error TS2339: Property 'x' does not exist on type '() => number'.
-    Entity.y;
-           ~
-!!! error TS2339: Property 'y' does not exist on type '() => number'.
+    Entity.y;

tests/baselines/reference/defaultExportsCannotMerge02.errors.txt

@@ -1,9 +1,6 @@
 tests/cases/conformance/es6/modules/m1.ts(2,22): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead.
 tests/cases/conformance/es6/modules/m1.ts(5,18): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead.
-tests/cases/conformance/es6/modules/m2.ts(3,1): error TS2348: Value of type 'typeof Decl' is not callable. Did you mean to include 'new'?
-tests/cases/conformance/es6/modules/m2.ts(6,8): error TS2503: Cannot find namespace 'Entity'.
-tests/cases/conformance/es6/modules/m2.ts(8,13): error TS2339: Property 'p1' does not exist on type 'Decl'.
-tests/cases/conformance/es6/modules/m2.ts(8,20): error TS2339: Property 'p2' does not exist on type 'Decl'.
+tests/cases/conformance/es6/modules/m2.ts(1,20): error TS2307: Cannot find module 'm1'.
 
 
 ==== tests/cases/conformance/es6/modules/m1.ts (2 errors) ====
@@ -25,20 +22,14 @@ tests/cases/conformance/es6/modules/m2.ts(8,20): error TS2339: Property 'p2' doe
         }
     }
     
-==== tests/cases/conformance/es6/modules/m2.ts (4 errors) ====
+==== tests/cases/conformance/es6/modules/m2.ts (1 errors) ====
     import Entity from "m1"
+                       ~~~~
+!!! error TS2307: Cannot find module 'm1'.
     
     Entity();
-    ~~~~~~~~
-!!! error TS2348: Value of type 'typeof Decl' is not callable. Did you mean to include 'new'?
     
     var x: Entity;
     var y: Entity.I;
-           ~~~~~~
-!!! error TS2503: Cannot find namespace 'Entity'.
     var z = new Entity();
-    var sum = z.p1 + z.p2
-                ~~
-!!! error TS2339: Property 'p1' does not exist on type 'Decl'.
-                       ~~
-!!! error TS2339: Property 'p2' does not exist on type 'Decl'.
+    var sum = z.p1 + z.p2

tests/baselines/reference/defaultExportsCannotMerge03.errors.txt

@@ -1,10 +1,7 @@
 tests/cases/conformance/es6/modules/m1.ts(2,22): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead.
 tests/cases/conformance/es6/modules/m1.ts(5,11): error TS2518: Only an ambient class can be merged with an interface.
 tests/cases/conformance/es6/modules/m1.ts(5,11): error TS2652: Merged declaration 'Decl' cannot include a default export declaration. Consider adding a separate 'export default Decl' declaration instead.
-tests/cases/conformance/es6/modules/m2.ts(3,1): error TS2348: Value of type 'typeof Decl' is not callable. Did you mean to include 'new'?
-tests/cases/conformance/es6/modules/m2.ts(6,8): error TS2503: Cannot find namespace 'Entity'.
-tests/cases/conformance/es6/modules/m2.ts(8,13): error TS2339: Property 'p1' does not exist on type 'Decl'.
-tests/cases/conformance/es6/modules/m2.ts(8,20): error TS2339: Property 'p2' does not exist on type 'Decl'.
+tests/cases/conformance/es6/modules/m2.ts(1,20): error TS2307: Cannot find module 'm1'.
 
 
 ==== tests/cases/conformance/es6/modules/m1.ts (3 errors) ====
@@ -28,20 +25,14 @@ tests/cases/conformance/es6/modules/m2.ts(8,20): error TS2339: Property 'p2' doe
         }
     }
     
-==== tests/cases/conformance/es6/modules/m2.ts (4 errors) ====
+==== tests/cases/conformance/es6/modules/m2.ts (1 errors) ====
     import Entity from "m1"
+                       ~~~~
+!!! error TS2307: Cannot find module 'm1'.
     
     Entity();
-    ~~~~~~~~
-!!! error TS2348: Value of type 'typeof Decl' is not callable. Did you mean to include 'new'?
     
     var x: Entity;
     var y: Entity.I;
-           ~~~~~~
-!!! error TS2503: Cannot find namespace 'Entity'.
     var z = new Entity();
-    var sum = z.p1 + z.p2
-                ~~
-!!! error TS2339: Property 'p1' does not exist on type 'Decl'.
-                       ~~
-!!! error TS2339: Property 'p2' does not exist on type 'Decl'.
+    var sum = z.p1 + z.p2

tests/baselines/reference/elidingImportNames.js

@@ -2,10 +2,10 @@
 
 //// [elidingImportNames_test.ts]
 
-import a = require('elidingImportNames_main'); // alias used in typeof
+import a = require('./elidingImportNames_main'); // alias used in typeof
 var b = a;
 var x: typeof a;
-import a2 = require('elidingImportNames_main1'); // alias not used in typeof
+import a2 = require('./elidingImportNames_main1'); // alias not used in typeof
 var b2 = a2;
 
 
@@ -20,8 +20,8 @@ exports.main = 10;
 //// [elidingImportNames_main1.js]
 exports.main = 10;
 //// [elidingImportNames_test.js]
-var a = require('elidingImportNames_main'); // alias used in typeof
+var a = require('./elidingImportNames_main'); // alias used in typeof
 var b = a;
 var x;
-var a2 = require('elidingImportNames_main1'); // alias not used in typeof
+var a2 = require('./elidingImportNames_main1'); // alias not used in typeof
 var b2 = a2;

tests/baselines/reference/elidingImportNames.symbols

@@ -1,6 +1,6 @@
 === tests/cases/compiler/elidingImportNames_test.ts ===
 
-import a = require('elidingImportNames_main'); // alias used in typeof
+import a = require('./elidingImportNames_main'); // alias used in typeof
 >a : Symbol(a, Decl(elidingImportNames_test.ts, 0, 0))
 
 var b = a;
@@ -11,7 +11,7 @@ var x: typeof a;
 >x : Symbol(x, Decl(elidingImportNames_test.ts, 3, 3))
 >a : Symbol(a, Decl(elidingImportNames_test.ts, 0, 0))
 
-import a2 = require('elidingImportNames_main1'); // alias not used in typeof
+import a2 = require('./elidingImportNames_main1'); // alias not used in typeof
 >a2 : Symbol(a2, Decl(elidingImportNames_test.ts, 3, 16))
 
 var b2 = a2;

tests/baselines/reference/elidingImportNames.types

@@ -1,6 +1,6 @@
 === tests/cases/compiler/elidingImportNames_test.ts ===
 
-import a = require('elidingImportNames_main'); // alias used in typeof
+import a = require('./elidingImportNames_main'); // alias used in typeof
 >a : typeof a
 
 var b = a;
@@ -11,7 +11,7 @@ var x: typeof a;
 >x : typeof a
 >a : typeof a
 
-import a2 = require('elidingImportNames_main1'); // alias not used in typeof
+import a2 = require('./elidingImportNames_main1'); // alias not used in typeof
 >a2 : typeof a2
 
 var b2 = a2;

tests/baselines/reference/emptyArrayBindingPatternParameter01.js

@@ -1,6 +1,5 @@
 //// [emptyArrayBindingPatternParameter01.ts]
 
-
 function f([]) {
     var x, y, z;
 }
@@ -9,3 +8,7 @@ function f([]) {
 function f(_a) {
     var x, y, z;
 }
+
+
+//// [emptyArrayBindingPatternParameter01.d.ts]
+declare function f([]: any[]): void;

tests/baselines/reference/emptyArrayBindingPatternParameter01.symbols

@@ -1,11 +1,10 @@
 === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter01.ts ===
 
-
 function f([]) {
 >f : Symbol(f, Decl(emptyArrayBindingPatternParameter01.ts, 0, 0))
 
     var x, y, z;
->x : Symbol(x, Decl(emptyArrayBindingPatternParameter01.ts, 3, 7))
->y : Symbol(y, Decl(emptyArrayBindingPatternParameter01.ts, 3, 10))
->z : Symbol(z, Decl(emptyArrayBindingPatternParameter01.ts, 3, 13))
+>x : Symbol(x, Decl(emptyArrayBindingPatternParameter01.ts, 2, 7))
+>y : Symbol(y, Decl(emptyArrayBindingPatternParameter01.ts, 2, 10))
+>z : Symbol(z, Decl(emptyArrayBindingPatternParameter01.ts, 2, 13))
 }

tests/baselines/reference/emptyArrayBindingPatternParameter01.types

@@ -1,6 +1,5 @@
 === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter01.ts ===
 
-
 function f([]) {
 >f : ([]: any[]) => void
 

tests/baselines/reference/emptyArrayBindingPatternParameter02.js

@@ -1,6 +1,5 @@
 //// [emptyArrayBindingPatternParameter02.ts]
 
-
 function f(a, []) {
     var x, y, z;
 }
@@ -9,3 +8,7 @@ function f(a, []) {
 function f(a, _a) {
     var x, y, z;
 }
+
+
+//// [emptyArrayBindingPatternParameter02.d.ts]
+declare function f(a: any, []: any[]): void;

tests/baselines/reference/emptyArrayBindingPatternParameter02.symbols

@@ -1,12 +1,11 @@
 === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts ===
 
-
 function f(a, []) {
 >f : Symbol(f, Decl(emptyArrayBindingPatternParameter02.ts, 0, 0))
->a : Symbol(a, Decl(emptyArrayBindingPatternParameter02.ts, 2, 11))
+>a : Symbol(a, Decl(emptyArrayBindingPatternParameter02.ts, 1, 11))
 
     var x, y, z;
->x : Symbol(x, Decl(emptyArrayBindingPatternParameter02.ts, 3, 7))
->y : Symbol(y, Decl(emptyArrayBindingPatternParameter02.ts, 3, 10))
->z : Symbol(z, Decl(emptyArrayBindingPatternParameter02.ts, 3, 13))
+>x : Symbol(x, Decl(emptyArrayBindingPatternParameter02.ts, 2, 7))
+>y : Symbol(y, Decl(emptyArrayBindingPatternParameter02.ts, 2, 10))
+>z : Symbol(z, Decl(emptyArrayBindingPatternParameter02.ts, 2, 13))
 }

tests/baselines/reference/emptyArrayBindingPatternParameter02.types

@@ -1,6 +1,5 @@
 === tests/cases/conformance/es6/destructuring/emptyArrayBindingPatternParameter02.ts ===
 
-
 function f(a, []) {
 >f : (a: any, []: any[]) => void
 >a : any

tests/baselines/reference/emptyArrayBindingPatternParameter03.js

@@ -1,6 +1,5 @@
 //// [emptyArrayBindingPatternParameter03.ts]
 
-
 function f(a, []) {
     var x, y, z;
 }
@@ -9,3 +8,7 @@ function f(a, []) {
 function f(a, _a) {
     var x, y, z;
 }
+
+
+//// [emptyArrayBindingPatternParameter03.d.ts]
+declare function f(a: any, []: any[]): void;