Merge branch 'master' into noEmitExtraVars

Author: rbuckton

src/compiler/checker.ts

@@ -9421,8 +9421,8 @@ namespace ts {
             let container = getSuperContainer(node, /*stopOnFunctions*/ true);
             let needToCaptureLexicalThis = false;
 
+            // adjust the container reference in case if super is used inside arrow functions with arbitrarily deep nesting
             if (!isCallExpression) {
-                // adjust the container reference in case if super is used inside arrow functions with arbitrary deep nesting
                 while (container && container.kind === SyntaxKind.ArrowFunction) {
                     container = getSuperContainer(container, /*stopOnFunctions*/ true);
                     needToCaptureLexicalThis = languageVersion < ScriptTarget.ES6;
@@ -14439,6 +14439,7 @@ namespace ts {
             // constructors of derived classes must contain at least one super call somewhere in their function body.
             const containingClassDecl = <ClassDeclaration>node.parent;
             if (getClassExtendsHeritageClauseElement(containingClassDecl)) {
+                captureLexicalThis(node.parent, containingClassDecl);
                 const classExtendsNull = classDeclarationExtendsNull(containingClassDecl);
                 const superCall = getSuperCallInConstructor(node);
                 if (superCall) {
@@ -17713,9 +17714,11 @@ namespace ts {
         }
 
         function checkGrammarModuleElementContext(node: Statement, errorMessage: DiagnosticMessage): boolean {
-            if (node.parent.kind !== SyntaxKind.SourceFile && node.parent.kind !== SyntaxKind.ModuleBlock && node.parent.kind !== SyntaxKind.ModuleDeclaration) {
-                return grammarErrorOnFirstToken(node, errorMessage);
+            const isInAppropriateContext = node.parent.kind === SyntaxKind.SourceFile || node.parent.kind === SyntaxKind.ModuleBlock || node.parent.kind === SyntaxKind.ModuleDeclaration;
+            if (!isInAppropriateContext) {
+                grammarErrorOnFirstToken(node, errorMessage);
             }
+            return !isInAppropriateContext;
         }
 
         function checkExportSpecifier(node: ExportSpecifier) {
@@ -17756,7 +17759,7 @@ namespace ts {
                 checkExpressionCached(node.expression);
             }
 
-            checkExternalModuleExports(<SourceFile | ModuleDeclaration>container);
+            checkExternalModuleExports(container);
 
             if (node.isExportEquals && !isInAmbientContext(node)) {
                 if (modulekind === ModuleKind.ES6) {

src/compiler/transformers/es6.ts

@@ -982,11 +982,11 @@ namespace ts {
     }
 
     /**
-      * Given an super call\property node returns a closest node where either
-      * - super call\property is legal in the node and not legal in the parent node the node.
+      * Given an super call/property node, returns the closest node where
+      * - a super call/property access is legal in the node and not legal in the parent node the node.
       *   i.e. super call is legal in constructor but not legal in the class body.
-      * - node is arrow function (so caller might need to call getSuperContainer in case it needs to climb higher)
-      * - super call\property is definitely illegal in the node (but might be legal in some subnode)
+      * - the container is an arrow function (so caller might need to call getSuperContainer again in case it needs to climb higher)
+      * - a super call/property is definitely illegal in the container (but might be legal in some subnode)
       *   i.e. super property access is illegal in function declaration but can be legal in the statement list
       */
     export function getSuperContainer(node: Node, stopOnFunctions: boolean): Node {

src/compiler/utilities.ts

@@ -2045,4 +2045,22 @@ namespace ts.projectSystem {
             assert.equal(snap.getLength(), expectedLength, "Incorrect snapshot size");
         }
     });
+
+    describe("Language service", () => {
+        it("should work correctly on case-sensitive file systems", () => {
+            const lib = {
+                path: "/a/Lib/lib.d.ts",
+                content: "let x: number"
+            };
+            const f = {
+                path: "/a/b/app.ts",
+                content: "let x = 1;"
+            };
+            const host = createServerHost([lib, f], { executingFilePath: "/a/Lib/tsc.js", useCaseSensitiveFileNames: true });
+            const projectService = createProjectService(host);
+            projectService.openClientFile(f.path);
+            projectService.checkNumberOfProjects({ inferredProjects: 1 });
+            projectService.inferredProjects[0].getLanguageService().getProgram();
+        });
+    });
 }

src/harness/unittests/tsserverProjectSystem.ts

@@ -1001,9 +1001,14 @@ namespace ts.server {
         }
 
         getScriptInfoForNormalizedPath(fileName: NormalizedPath) {
-            return this.filenameToScriptInfo.get(normalizedPathToPath(fileName, this.host.getCurrentDirectory(), this.toCanonicalFileName));
+            return this.getScriptInfoForPath(normalizedPathToPath(fileName, this.host.getCurrentDirectory(), this.toCanonicalFileName));
         }
 
+        getScriptInfoForPath(fileName: Path) {
+            return this.filenameToScriptInfo.get(fileName);
+        }
+
+
         setHostConfiguration(args: protocol.ConfigureRequestArguments) {
             if (args.file) {
                 const info = this.getScriptInfoForNormalizedPath(toNormalizedPath(args.file));

src/server/editorServices.ts

@@ -215,7 +215,13 @@ namespace ts.server {
         }
 
         getScriptInfos() {
-            return map(this.program.getSourceFiles(), sourceFile => this.getScriptInfoLSHost(sourceFile.path));
+            return map(this.program.getSourceFiles(), sourceFile => {
+                const scriptInfo = this.projectService.getScriptInfoForPath(sourceFile.path);
+                if (!scriptInfo) {
+                    Debug.assert(false, `scriptInfo for a file '${sourceFile.fileName}' is missing.`);
+                }
+                return scriptInfo;
+            });
         }
 
         getFileEmitOutput(info: ScriptInfo, emitOnlyDtsFiles: boolean) {

src/server/project.ts

@@ -947,7 +947,7 @@ namespace ts {
 
         let lastTypesRootVersion = 0;
 
-        const useCaseSensitivefileNames = false;
+        const useCaseSensitivefileNames = host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames();
         const cancellationToken = new CancellationTokenObject(host.getCancellationToken && host.getCancellationToken());
 
         const currentDirectory = host.getCurrentDirectory();

src/services/services.ts

@@ -38,7 +38,7 @@ var A;
     var Point3d = (function (_super) {
         __extends(Point3d, _super);
         function Point3d() {
-            _super.apply(this, arguments);
+            return _super.apply(this, arguments) || this;
         }
         return Point3d;
     }(Point));

tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.js

@@ -41,7 +41,7 @@ var A;
     var Point3d = (function (_super) {
         __extends(Point3d, _super);
         function Point3d() {
-            _super.apply(this, arguments);
+            return _super.apply(this, arguments) || this;
         }
         return Point3d;
     }(Point));

tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.js

@@ -22,7 +22,7 @@ var __extends = (this && this.__extends) || function (d, b) {
     var B = (function (_super) {
         __extends(B, _super);
         function B() {
-            _super.apply(this, arguments);
+            return _super.apply(this, arguments) || this;
         }
         return B;
     }(A));