Merge branch 'master' into fix15618

Author: rbuckton

.mailmap

@@ -248,4 +248,23 @@ rdosanjh  <[email protected]> # Raj Dosanjh
 gdh1995  <[email protected]> # Dahan Gong
 cedvdb  <[email protected]> # @cedvdb
 kpreisser  <[email protected]> # K. Preißer
-e-cloud  <[email protected]> # @e-cloud
+e-cloud  <[email protected]> # @e-cloud
+Andrew Casey  <[email protected]> Andrew Casey  <[email protected]>
+Andrew Stegmaier  <[email protected]>
+Benny Neugebauer  <[email protected]>
+Blaine Bublitz  <[email protected]>
+Charles Pierce  <[email protected]>
+Daniel Król  <[email protected]>
+Diogo Franco (Kovensky)  <[email protected]>
+Donald Pipowitch  <[email protected]>
+Halasi Tamás  <[email protected]>
+Ika  <[email protected]>
+Joe Chung  <[email protected]>
+Kate Miháliková  <[email protected]>
+Mohsen Azimi  <[email protected]>
+Noel Varanda  <[email protected]>
+Reiner Dolp  <[email protected]>
+t_  <[email protected]> # @t_
+TravCav  <[email protected]> # @TravCav
+Vladimir Kurchatkin  <[email protected]>
+William Orr  <[email protected]>

AUTHORS.md

@@ -15,7 +15,9 @@ TypeScript is authored by:
 * Anders Hejlsberg
 * Andreas Martin
 * Andrej Baran 
+* Andrew Casey 
 * Andrew Ochsner 
+* Andrew Stegmaier 
 * Andrew Z Allen
 * András Parditka 
 * Andy Hanson
@@ -31,14 +33,17 @@ TypeScript is authored by:
 * Ben Duffield
 * Ben Mosher 
 * Benjamin Bock 
+* Benny Neugebauer 
 * Bill Ticehurst
+* Blaine Bublitz 
 * Blake Embrey
 * @bootstraponline
 * Bowden Kelly
 * Brett Mayen
 * Bryan Forbes
 * Caitlin Potter
 * @cedvdb
+* Charles Pierce 
 * Charly POLY 
 * Chris Bubernak
 * Christophe Vidal 
@@ -52,6 +57,7 @@ TypeScript is authored by:
 * Dan Corder
 * Dan Quirk
 * Daniel Hollocher
+* Daniel Król 
 * Daniel Lehenbauer
 * Daniel Rosenwasser
 * David Kmenta
@@ -60,9 +66,11 @@ TypeScript is authored by:
 * David Souther
 * Denis Nedelyaev
 * Dick van den Brink
+* Diogo Franco (Kovensky) 
 * Dirk Bäumer
 * Dirk Holtwick
 * Dom Chen 
+* Donald Pipowitch 
 * Doug Ilijev
 * @e-cloud
 * Elisée Maurer
@@ -89,12 +97,14 @@ TypeScript is authored by:
 * Guilherme Oenning
 * Guillaume Salles
 * Guy Bedford
+* Halasi Tamás 
 * Harald Niesche
 * Hendrik Liebau 
 * Herrington Darkholme
 * Homa Wong 
 * Iain Monro
 * Igor Novozhilov
+* Ika 
 * Ingvar Stepanyan
 * Isiah Meadows
 * Ivo Gabe de Wolff
@@ -111,6 +121,7 @@ TypeScript is authored by:
 * Jeffrey Morlan
 * Jesse Schalken
 * Jiri Tobisek
+* Joe Chung 
 * Joel Day 
 * Joey Wilson
 * Johannes Rieken
@@ -131,6 +142,7 @@ TypeScript is authored by:
 * K. Preißer
 * Kagami Sascha Rosylight
 * Kanchalai Tanglertsampan
+* Kate Miháliková 
 * Keith Mashinter
 * Ken Howard
 * Kenji Imamula
@@ -159,13 +171,15 @@ TypeScript is authored by:
 * Mike Busyrev 
 * Mine Starks 
 * Mohamed Hegazy
+* Mohsen Azimi 
 * Myles Megyesi 
 * Natalie Coley
 * Nathan Shively-Sanders
 * Nathan Yee
 * Nicolas Henry
 * Nima Zahedi
 * Noah Chen 
+* Noel Varanda 
 * Noj Vek
 * Oleg Mihailik
 * Oleksandr Chekhovskyi
@@ -186,6 +200,7 @@ TypeScript is authored by:
 * Punya Biswal
 * Rado Kirov
 * Raj Dosanjh
+* Reiner Dolp 
 * Richard Karmazín 
 * Richard Knoll
 * Richard Sentino
@@ -213,6 +228,7 @@ TypeScript is authored by:
 * Sudheesh Singanamalla 
 * Sébastien Arod
 * @T18970237136
+* @t_
 * Tarik Ozket
 * Tetsuharu Ohzeki
 * Thomas Loubiou
@@ -225,13 +241,16 @@ TypeScript is authored by:
 * togru
 * Tomas Grubliauskas
 * Torben Fitschen 
+* @TravCav
 * TruongSinh Tran-Nguyen
 * Vadi Taslim 
 * Vidar Tonaas Fauske
 * Viktor Zozulyak
 * Vilic Vane
+* Vladimir Kurchatkin 
 * Vladimir Matveev
 * Wesley Wigham
+* William Orr 
 * York Yao
 * @yortus
 * Yuichi Nukiyama

src/compiler/checker.ts

@@ -6841,21 +6841,46 @@ namespace ts {
             return undefined;
         }
 
-        function resolveTypeReferenceName(typeReferenceName: EntityNameExpression | EntityName) {
+        function resolveTypeReferenceName(typeReferenceName: EntityNameExpression | EntityName, meaning: SymbolFlags) {
             if (!typeReferenceName) {
                 return unknownSymbol;
             }
 
-            return resolveEntityName(typeReferenceName, SymbolFlags.Type) || unknownSymbol;
+            return resolveEntityName(typeReferenceName, meaning) || unknownSymbol;
         }
 
         function getTypeReferenceType(node: TypeReferenceType, symbol: Symbol) {
             const typeArguments = typeArgumentsFromTypeReferenceNode(node); // Do unconditionally so we mark type arguments as referenced.
-
             if (symbol === unknownSymbol) {
                 return unknownType;
             }
 
+            const type = getTypeReferenceTypeWorker(node, symbol, typeArguments);
+            if (type) {
+                return type;
+            }
+
+            if (symbol.flags & SymbolFlags.Value && node.kind === SyntaxKind.JSDocTypeReference) {
+                // A JSDocTypeReference may have resolved to a value (as opposed to a type). If
+                // the symbol is a constructor function, return the inferred class type; otherwise,
+                // the type of this reference is just the type of the value we resolved to.
+                const valueType = getTypeOfSymbol(symbol);
+                if (valueType.symbol && !isInferredClassType(valueType)) {
+                    const referenceType = getTypeReferenceTypeWorker(node, valueType.symbol, typeArguments);
+                    if (referenceType) {
+                        return referenceType;
+                    }
+                }
+
+                // Resolve the type reference as a Type for the purpose of reporting errors.
+                resolveTypeReferenceName(getTypeReferenceName(node), SymbolFlags.Type);
+                return valueType;
+            }
+
+            return getTypeFromNonGenericTypeReference(node, symbol);
+        }
+
+        function getTypeReferenceTypeWorker(node: TypeReferenceType, symbol: Symbol, typeArguments: Type[]): Type | undefined {
             if (symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
                 return getTypeFromClassOrInterfaceReference(node, symbol, typeArguments);
             }
@@ -6864,14 +6889,9 @@ namespace ts {
                 return getTypeFromTypeAliasReference(node, symbol, typeArguments);
             }
 
-            if (symbol.flags & SymbolFlags.Value && node.kind === SyntaxKind.JSDocTypeReference) {
-                // A JSDocTypeReference may have resolved to a value (as opposed to a type). In
-                // that case, the type of this reference is just the type of the value we resolved
-                // to.
-                return getTypeOfSymbol(symbol);
+            if (symbol.flags & SymbolFlags.Function && node.kind === SyntaxKind.JSDocTypeReference && (symbol.members || getJSDocClassTag(symbol.valueDeclaration))) {
+                return getInferredClassType(symbol);
             }
-
-            return getTypeFromNonGenericTypeReference(node, symbol);
         }
 
         function getPrimitiveTypeFromJSDocTypeReference(node: JSDocTypeReference): Type {
@@ -6914,22 +6934,13 @@ namespace ts {
             if (!links.resolvedType) {
                 let symbol: Symbol;
                 let type: Type;
+                let meaning = SymbolFlags.Type;
                 if (node.kind === SyntaxKind.JSDocTypeReference) {
-                    type = getPrimitiveTypeFromJSDocTypeReference(<JSDocTypeReference>node);
-                    if (!type) {
-                        const typeReferenceName = getTypeReferenceName(node);
-                        symbol = resolveTypeReferenceName(typeReferenceName);
-                        type = getTypeReferenceType(node, symbol);
-                    }
+                    type = getPrimitiveTypeFromJSDocTypeReference(node);
+                    meaning |= SymbolFlags.Value;
                 }
-                else {
-                    // We only support expressions that are simple qualified names. For other expressions this produces undefined.
-                    const typeNameOrExpression: EntityNameOrEntityNameExpression = node.kind === SyntaxKind.TypeReference
-                        ? (<TypeReferenceNode>node).typeName
-                        : isEntityNameExpression((<ExpressionWithTypeArguments>node).expression)
-                            ? <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression
-                            : undefined;
-                    symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol;
+                if (!type) {
+                    symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning);
                     type = getTypeReferenceType(node, symbol);
                 }
                 // Cache both the resolved symbol and the resolved type. The resolved symbol is needed in when we check the
@@ -8058,7 +8069,7 @@ namespace ts {
             const result = createSignature(signature.declaration, freshTypeParameters,
                 signature.thisParameter && instantiateSymbol(signature.thisParameter, mapper),
                 instantiateList(signature.parameters, mapper, instantiateSymbol),
-                instantiateType(signature.resolvedReturnType, mapper),
+                /*resolvedReturnType*/ undefined,
                 freshTypePredicate,
                 signature.minArgumentCount, signature.hasRestParameter, signature.hasLiteralTypes);
             result.target = signature;
@@ -16176,6 +16187,12 @@ namespace ts {
             return links.inferredClassType;
         }
 
+        function isInferredClassType(type: Type) {
+            return type.symbol
+                && getObjectFlags(type) & ObjectFlags.Anonymous
+                && getSymbolLinks(type.symbol).inferredClassType === type;
+        }
+
         /**
          * Syntactically and semantically checks a call or new expression.
          * @param node The call/new expression to be checked.
@@ -19398,8 +19415,8 @@ namespace ts {
 
         function checkFunctionDeclaration(node: FunctionDeclaration): void {
             if (produceDiagnostics) {
-                checkFunctionOrMethodDeclaration(node) || checkGrammarForGenerator(node);
-
+                checkFunctionOrMethodDeclaration(node);
+                checkGrammarForGenerator(node);
                 checkCollisionWithCapturedSuperVariable(node, node.name);
                 checkCollisionWithCapturedThisVariable(node, node.name);
                 checkCollisionWithCapturedNewTargetVariable(node, node.name);

src/compiler/emitter.ts

@@ -959,7 +959,7 @@ namespace ts {
         function emitConstructorType(node: ConstructorTypeNode) {
             write("new ");
             emitTypeParameters(node, node.typeParameters);
-            emitParametersForArrow(node, node.parameters);
+            emitParameters(node, node.parameters);
             write(" => ");
             emit(node.type);
         }
@@ -2283,11 +2283,25 @@ namespace ts {
             emitList(parentNode, parameters, ListFormat.Parameters);
         }
 
-        function emitParametersForArrow(parentNode: Node, parameters: NodeArray<ParameterDeclaration>) {
-            if (parameters &&
-                parameters.length === 1 &&
-                parameters[0].type === undefined &&
-                parameters[0].pos === parentNode.pos) {
+        function canEmitSimpleArrowHead(parentNode: FunctionTypeNode | ArrowFunction, parameters: NodeArray<ParameterDeclaration>) {
+            const parameter = singleOrUndefined(parameters);
+            return parameter
+                && parameter.pos === parentNode.pos // may not have parsed tokens between parent and parameter
+                && !(isArrowFunction(parentNode) && parentNode.type) // arrow function may not have return type annotation
+                && !some(parentNode.decorators)     // parent may not have decorators
+                && !some(parentNode.modifiers)      // parent may not have modifiers
+                && !some(parentNode.typeParameters) // parent may not have type parameters
+                && !some(parameter.decorators)      // parameter may not have decorators
+                && !some(parameter.modifiers)       // parameter may not have modifiers
+                && !parameter.dotDotDotToken        // parameter may not be rest
+                && !parameter.questionToken         // parameter may not be optional
+                && !parameter.type                  // parameter may not have a type annotation
+                && !parameter.initializer           // parameter may not have an initializer
+                && isIdentifier(parameter.name);    // parameter name must be identifier
+        }
+
+        function emitParametersForArrow(parentNode: FunctionTypeNode | ArrowFunction, parameters: NodeArray<ParameterDeclaration>) {
+            if (canEmitSimpleArrowHead(parentNode, parameters)) {
                 emit(parameters[0]);
             }
             else {

src/compiler/factory.ts

@@ -228,7 +228,7 @@ namespace ts {
 
     // Signature elements
 
-    export function createTypeParameterDeclaration(name: string | Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined) {
+    export function createTypeParameterDeclaration(name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode) {
         const node = createSynthesizedNode(SyntaxKind.TypeParameter) as TypeParameterDeclaration;
         node.name = asName(name);
         node.constraint = constraint;

src/compiler/tsc.ts

@@ -662,6 +662,10 @@ namespace ts {
     }
 }
 
+if (ts.Debug.isDebugging) {
+    ts.Debug.enableDebugInfo();
+}
+
 if (ts.sys.tryEnableSourceMapsForHost && /^development$/i.test(ts.sys.getEnvironmentVariable("NODE_ENV"))) {
     ts.sys.tryEnableSourceMapsForHost();
 }