Merge branch 'master' into theyreNotTHATSpecial

Author: DanielRosenwasser

AUTHORS.md

@@ -2,9 +2,11 @@ TypeScript is authored by:
 
 * Adam Freidin
 * Ahmad Farid 
+* Akshar Patel
 * Anders Hejlsberg
 * Arnav Singh
 * Arthur Ozga
+* Asad Saeeduddin
 * Basarat Ali Syed 
 * Ben Duffield
 * Bill Ticehurst 
@@ -15,52 +17,67 @@ TypeScript is authored by:
 * Colby Russell 
 * Colin Snover
 * Cyrus Najmabadi
+* Dan Corder
 * Dan Quirk 
 * Daniel Rosenwasser
+* @dashaus
 * David Li 
 * Denis Nedelyaev
 * Dick van den Brink
 * Dirk Bäumer
+* Dirk Holtwick
 * Eyas Sharaiha
+* @falsandtru
 * Frank Wallis 
 * Gabriel Isenberg
 * Gilad Peleg 
 * Graeme Wicksted
 * Guillaume Salles 
+* Guy Bedford
 * Harald Niesche
+* Iain Monro
 * Ingvar Stepanyan
 * Ivo Gabe de Wolff 
 * James Whitney 
 * Jason Freeman
+* Jason Killian
 * Jason Ramsay 
 * Jed Mao
+* Jeffrey Morlan
 * Johannes Rieken 
 * John Vilk
 * Jonathan Bond-Caron
 * Jonathan Park
 * Jonathan Turner
+* Jonathon Smith
 * Josh Kalderimis
 * Julian Williams
 * Kagami Sascha Rosylight
 * Keith Mashinter
 * Ken Howard
 * Kenji Imamula
 * Lorant Pinter 
+* Lucien Greathouse
 * Martin Všetička
 * Masahiro Wakame
+* Mattias Buelens
 * Max Deepfield
 * Micah Zoltu 
 * Mohamed Hegazy 
 * Nathan Shively-Sanders
+* Nathan Yee
 * Oleg Mihailik
 * Oleksandr Chekhovskyi 
 * Paul van Brenk 
+* @pcbro
 * Pedro Maltez 
 * Philip Bulley
 * piloopin
 * @progre
 * Punya Biswal
+* Richard Sentino
 * Ron Buckton 
+* Rowan Wyborn
 * Ryan Cavanaugh 
 * Ryohei Ikegami
 * Sébastien Arod
@@ -71,7 +88,9 @@ TypeScript is authored by:
 * Solal Pirelli
 * Stan Thomas
 * Steve Lucco
+* Thomas Loubiou
 * Tien Hoanhtien
+* Tim Perry
 * Tingan Ho
 * togru
 * Tomas Grubliauskas
@@ -81,5 +100,6 @@ TypeScript is authored by:
 * Wesley Wigham
 * York Yao
 * Yui Tanglertsampan
+* Yuichi Nukiyama
 * Zev Spitz 
 * Zhengbo Li

src/compiler/binder.ts

@@ -1462,7 +1462,7 @@ namespace ts {
         function bindCallExpression(node: CallExpression) {
             // We're only inspecting call expressions to detect CommonJS modules, so we can skip
             // this check if we've already seen the module indicator
-            if (!file.commonJsModuleIndicator && isRequireCall(node)) {
+            if (!file.commonJsModuleIndicator && isRequireCall(node, /*checkArgumentIsStringLiteral*/false)) {
                 setCommonJsModuleIndicator(node);
             }
         }

src/compiler/checker.ts

@@ -637,18 +637,21 @@ namespace ts {
             }
         }
 
-        function emitClassMemberDeclarationFlags(node: Declaration) {
-            if (node.flags & NodeFlags.Private) {
+        function emitClassMemberDeclarationFlags(flags: NodeFlags) {
+            if (flags & NodeFlags.Private) {
                 write("private ");
             }
-            else if (node.flags & NodeFlags.Protected) {
+            else if (flags & NodeFlags.Protected) {
                 write("protected ");
             }
 
-            if (node.flags & NodeFlags.Static) {
+            if (flags & NodeFlags.Static) {
                 write("static ");
             }
-            if (node.flags & NodeFlags.Abstract) {
+            if (flags & NodeFlags.Readonly) {
+                write("readonly ");
+            }
+            if (flags & NodeFlags.Abstract) {
                 write("abstract ");
             }
         }
@@ -1074,7 +1077,7 @@ namespace ts {
             }
 
             emitJsDocComments(node);
-            emitClassMemberDeclarationFlags(node);
+            emitClassMemberDeclarationFlags(node.flags);
             emitVariableDeclaration(<VariableDeclaration>node);
             write(";");
             writeLine();
@@ -1227,7 +1230,7 @@ namespace ts {
             if (node === accessors.firstAccessor) {
                 emitJsDocComments(accessors.getAccessor);
                 emitJsDocComments(accessors.setAccessor);
-                emitClassMemberDeclarationFlags(node);
+                emitClassMemberDeclarationFlags(node.flags | (accessors.setAccessor ? 0 : NodeFlags.Readonly));
                 writeTextOfNode(currentText, node.name);
                 if (!(node.flags & NodeFlags.Private)) {
                     accessorWithTypeAnnotation = node;
@@ -1314,7 +1317,7 @@ namespace ts {
                     emitModuleElementDeclarationFlags(node);
                 }
                 else if (node.kind === SyntaxKind.MethodDeclaration) {
-                    emitClassMemberDeclarationFlags(node);
+                    emitClassMemberDeclarationFlags(node.flags);
                 }
                 if (node.kind === SyntaxKind.FunctionDeclaration) {
                     write("function ");
@@ -1342,15 +1345,17 @@ namespace ts {
             const prevEnclosingDeclaration = enclosingDeclaration;
             enclosingDeclaration = node;
 
-            // Construct signature or constructor type write new Signature
-            if (node.kind === SyntaxKind.ConstructSignature || node.kind === SyntaxKind.ConstructorType) {
-                write("new ");
-            }
-            emitTypeParameters(node.typeParameters);
             if (node.kind === SyntaxKind.IndexSignature) {
+                // Index signature can have readonly modifier
+                emitClassMemberDeclarationFlags(node.flags);
                 write("[");
             }
             else {
+                // Construct signature or constructor type write new Signature
+                if (node.kind === SyntaxKind.ConstructSignature || node.kind === SyntaxKind.ConstructorType) {
+                    write("new ");
+                }
+                emitTypeParameters(node.typeParameters);
                 write("(");
             }
 

src/compiler/declarationEmitter.ts

@@ -199,6 +199,10 @@
         "category": "Error",
         "code": 1063
     },
+    "The return type of an async function or method must be the global Promise<T> type.": {
+        "category": "Error",
+        "code": 1064
+    },
     "In ambient enum declarations member initializer must be constant expression.": {
         "category": "Error",
         "code": 1066
@@ -802,7 +806,7 @@
     "A decorator can only decorate a method implementation, not an overload.": {
         "category": "Error",
         "code": 1249
-    }, 
+    },
     "'with' statements are not allowed in an async function block.": {
         "category": "Error",
         "code": 1300
@@ -1695,6 +1699,10 @@
         "category": "Error",
         "code": 2528
     },
+    "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module containing async functions.": {
+        "category": "Error",
+        "code": 2529
+    },
     "JSX element attributes type '{0}' may not be a union type.": {
         "category": "Error",
         "code": 2600
@@ -2763,5 +2771,9 @@
     "JSX element '{0}' has no corresponding closing tag.": {
       "category": "Error",
       "code": 17008
+    },
+    "'super' must be called before accessing 'this' in the constructor of a derived class.": {
+      "category": "Error",
+      "code": 17009
     }
 }

src/compiler/diagnosticMessages.json

@@ -320,7 +320,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 
         const awaiterHelper = `
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new P(function (resolve, reject) {
+    return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
         function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
@@ -477,6 +477,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             // =>
             // var x;... exporter("x", x = 1)
             let exportFunctionForFile: string;
+            let contextObjectForFile: string;
 
             let generatedNameSet: Map<string>;
             let nodeToGeneratedName: string[];
@@ -557,6 +558,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 currentText = undefined;
                 currentLineMap = undefined;
                 exportFunctionForFile = undefined;
+                contextObjectForFile = undefined;
                 generatedNameSet = undefined;
                 nodeToGeneratedName = undefined;
                 computedPropertyNamesToGeneratedNames = undefined;
@@ -585,6 +587,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 currentText = sourceFile.text;
                 currentLineMap = getLineStarts(sourceFile);
                 exportFunctionForFile = undefined;
+                contextObjectForFile = undefined;
                 isEs6Module = sourceFile.symbol && sourceFile.symbol.exports && !!sourceFile.symbol.exports["___esModule"];
                 renamedDependencies = sourceFile.renamedDependencies;
                 currentFileIdentifiers = sourceFile.identifiers;
@@ -4561,11 +4564,11 @@ const _super = (function (geti, seti) {
                     write(", void 0, ");
                 }
 
-                if (promiseConstructor) {
-                    emitEntityNameAsExpression(promiseConstructor, /*useFallback*/ false);
+                if (languageVersion >= ScriptTarget.ES6 || !promiseConstructor) {
+                    write("void 0");
                 }
                 else {
-                    write("Promise");
+                    emitEntityNameAsExpression(promiseConstructor, /*useFallback*/ false);
                 }
 
                 // Emit the call to __awaiter.
@@ -7058,6 +7061,7 @@ const _super = (function (geti, seti) {
                 Debug.assert(!exportFunctionForFile);
                 // make sure that  name of 'exports' function does not conflict with existing identifiers
                 exportFunctionForFile = makeUniqueName("exports");
+                contextObjectForFile = makeUniqueName("context");
                 writeLine();
                 write("System.register(");
                 writeModuleName(node, emitRelativePathAsModuleName);
@@ -7068,14 +7072,22 @@ const _super = (function (geti, seti) {
 
                 for (let i = 0; i < externalImports.length; i++) {
                     const text = getExternalModuleNameText(externalImports[i], emitRelativePathAsModuleName);
-                    if (hasProperty(groupIndices, text)) {
+                    if (text === undefined) {
+                        continue;
+                    }
+
+                    // text should be quoted string
+                    // for deduplication purposes in key remove leading and trailing quotes so 'a' and "a" will be considered the same                     
+                    const key = text.substr(1, text.length - 2);
+
+                    if (hasProperty(groupIndices, key)) {
                         // deduplicate/group entries in dependency list by the dependency name
-                        const groupIndex = groupIndices[text];
+                        const groupIndex = groupIndices[key];
                         dependencyGroups[groupIndex].push(externalImports[i]);
                         continue;
                     }
                     else {
-                        groupIndices[text] = dependencyGroups.length;
+                        groupIndices[key] = dependencyGroups.length;
                         dependencyGroups.push([externalImports[i]]);
                     }
 
@@ -7085,10 +7097,13 @@ const _super = (function (geti, seti) {
 
                     write(text);
                 }
-                write(`], function(${exportFunctionForFile}) {`);
+                write(`], function(${exportFunctionForFile}, ${contextObjectForFile}) {`);
                 writeLine();
                 increaseIndent();
                 const startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true, /*ensureUseStrict*/ true);
+                writeLine();
+                write(`var __moduleName = ${contextObjectForFile} && ${contextObjectForFile}.id;`);
+                writeLine();
                 emitEmitHelpers(node);
                 emitCaptureThisForNodeIfNecessary(node);
                 emitSystemModuleBody(node, dependencyGroups, startIndex);

src/compiler/emitter.ts

@@ -4017,7 +4017,7 @@ namespace ts {
                 setDecoratorContext(/*val*/ true);
             }
 
-            return finishNode(node);
+            return addJSDocComment(finishNode(node));
         }
 
         function parseOptionalIdentifier() {
@@ -4301,13 +4301,13 @@ namespace ts {
                 const labeledStatement = <LabeledStatement>createNode(SyntaxKind.LabeledStatement, fullStart);
                 labeledStatement.label = <Identifier>expression;
                 labeledStatement.statement = parseStatement();
-                return finishNode(labeledStatement);
+                return addJSDocComment(finishNode(labeledStatement));
             }
             else {
                 const expressionStatement = <ExpressionStatement>createNode(SyntaxKind.ExpressionStatement, fullStart);
                 expressionStatement.expression = expression;
                 parseSemicolon();
-                return finishNode(expressionStatement);
+                return addJSDocComment(finishNode(expressionStatement));
             }
         }
 

src/compiler/parser.ts

@@ -1328,7 +1328,7 @@ namespace ts {
             }
 
             function collectRequireCalls(node: Node): void {
-                if (isRequireCall(node)) {
+                if (isRequireCall(node, /*checkArgumentIsStringLiteral*/true)) {
                     (imports || (imports = [])).push(<StringLiteral>(<CallExpression>node).arguments[0]);
                 }
                 else {

src/compiler/program.ts

@@ -2070,6 +2070,7 @@ namespace ts {
         LoopWithCapturedBlockScopedBinding = 0x00010000, // Loop that contains block scoped variable captured in closure
         CapturedBlockScopedBinding = 0x00020000,         // Block-scoped binding that is captured in some function
         BlockScopedBindingInLoop   = 0x00040000,         // Block-scoped binding with declaration nested inside iteration statement
+        HasSeenSuperCall           = 0x00080000,  // Set during the binding when encounter 'super'
     }
 
     /* @internal */