Merge branch 'master' into fix15618

.mailmap

@@ -248,4 +248,23 @@ rdosanjh  <me@rajdeep.io> # Raj Dosanjh
 gdh1995  <gdh1995@qq.com> # Dahan Gong
 cedvdb  <cedvandenbosch@gmail.com> # @cedvdb
 kpreisser  <kpreisser@users.noreply.github.com> # K. Preißer
-e-cloud  <saintscott119@gmail.com> # @e-cloud
+e-cloud  <saintscott119@gmail.com> # @e-cloud
+Andrew Casey  <amcasey@users.noreply.github.com> Andrew Casey  <andrew.casey@microsoft.com>
+Andrew Stegmaier  <andrew.stegmaier@gmail.com>
+Benny Neugebauer  <bn@bennyn.de>
+Blaine Bublitz  <blaine.bublitz@gmail.com>
+Charles Pierce  <cpierce.grad@gmail.com>
+Daniel Król  <daniel@krol.me>
+Diogo Franco (Kovensky)  <diogomfranco@gmail.com>
+Donald Pipowitch  <pipo@senaeh.de>
+Halasi Tamás  <trusted.tomato@gmail.com>
+Ika  <ikatyang@gmail.com>
+Joe Chung  <joechung@microsoft.com>
+Kate Miháliková  <kate@katemihalikova.cz>
+Mohsen Azimi  <mazimi@lyft.com>
+Noel Varanda  <ncwvaranda@gmail.com>
+Reiner Dolp  <reiner-dolp@users.noreply.github.com>
+t_  <t-mrt@users.noreply.github.com> # @t_
+TravCav  <xurrux@gmail.com> # @TravCav
+Vladimir Kurchatkin  <vladimir.kurchatkin@gmail.com>
+William Orr  <will@worrbase.com>

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,7 +33,9 @@ TypeScript is authored by:
 * Ben Duffield
 * Ben Mosher 
 * Benjamin Bock 
+* Benny Neugebauer 
 * Bill Ticehurst
+* Blaine Bublitz 
 * Blake Embrey
 * @bootstraponline
 * Bowden Kelly
@@ -39,6 +43,7 @@ TypeScript is authored by:
 * 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,6 +171,7 @@ TypeScript is authored by:
 * Mike Busyrev 
 * Mine Starks 
 * Mohamed Hegazy
+* Mohsen Azimi 
 * Myles Megyesi 
 * Natalie Coley
 * Nathan Shively-Sanders
@@ -166,6 +179,7 @@ TypeScript is authored by:
 * 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();
 }

src/compiler/visitor.ts

@@ -1517,35 +1517,7 @@ namespace ts {
     }
 
     export namespace Debug {
-        if (isDebugging) {
-            // Add additional properties in debug mode to assist with debugging.
-            Object.defineProperties(objectAllocator.getSymbolConstructor().prototype, {
-                "__debugFlags": { get(this: Symbol) { return formatSymbolFlags(this.flags); } }
-            });
-
-            Object.defineProperties(objectAllocator.getTypeConstructor().prototype, {
-                "__debugFlags": { get(this: Type) { return formatTypeFlags(this.flags); } },
-                "__debugObjectFlags": { get(this: Type) { return this.flags & TypeFlags.Object ? formatObjectFlags((<ObjectType>this).objectFlags) : ""; } },
-                "__debugTypeToString": { value(this: Type) { return this.checker.typeToString(this); } },
-            });
-
-            for (const ctor of [objectAllocator.getNodeConstructor(), objectAllocator.getIdentifierConstructor(), objectAllocator.getTokenConstructor(), objectAllocator.getSourceFileConstructor()]) {
-                if (!ctor.prototype.hasOwnProperty("__debugKind")) {
-                    Object.defineProperties(ctor.prototype, {
-                        "__debugKind": { get(this: Node) { return formatSyntaxKind(this.kind); } },
-                        "__debugModifierFlags": { get(this: Node) { return formatModifierFlags(getModifierFlagsNoCache(this)); } },
-                        "__debugTransformFlags": { get(this: Node) { return formatTransformFlags(this.transformFlags); } },
-                        "__debugEmitFlags": { get(this: Node) { return formatEmitFlags(getEmitFlags(this)); } },
-                        "__debugGetText": { value(this: Node, includeTrivia?: boolean) {
-                            if (nodeIsSynthesized(this)) return "";
-                            const parseNode = getParseTreeNode(this);
-                            const sourceFile = parseNode && getSourceFileOfNode(parseNode);
-                            return sourceFile ? getSourceTextOfNodeFromSourceFile(sourceFile, parseNode, includeTrivia) : "";
-                        } }
-                    });
-                }
-            }
-        }
+        let isDebugInfoEnabled = false;
 
         export const failBadSyntaxKind = shouldAssert(AssertionLevel.Normal)
             ? (node: Node, message?: string): void => fail(
@@ -1592,5 +1564,51 @@ namespace ts {
                 () => `Node ${formatSyntaxKind(node.kind)} was unexpected'.`,
                 assertMissingNode)
             : noop;
+
+        /**
+         * Injects debug information into frequently used types.
+         */
+        export function enableDebugInfo() {
+            if (isDebugInfoEnabled) return;
+
+            // Add additional properties in debug mode to assist with debugging.
+            Object.defineProperties(objectAllocator.getSymbolConstructor().prototype, {
+                "__debugFlags": { get(this: Symbol) { return formatSymbolFlags(this.flags); } }
+            });
+
+            Object.defineProperties(objectAllocator.getTypeConstructor().prototype, {
+                "__debugFlags": { get(this: Type) { return formatTypeFlags(this.flags); } },
+                "__debugObjectFlags": { get(this: Type) { return this.flags & TypeFlags.Object ? formatObjectFlags((<ObjectType>this).objectFlags) : ""; } },
+                "__debugTypeToString": { value(this: Type) { return this.checker.typeToString(this); } },
+            });
+
+            const nodeConstructors = [
+                objectAllocator.getNodeConstructor(),
+                objectAllocator.getIdentifierConstructor(),
+                objectAllocator.getTokenConstructor(),
+                objectAllocator.getSourceFileConstructor()
+            ];
+
+            for (const ctor of nodeConstructors) {
+                if (!ctor.prototype.hasOwnProperty("__debugKind")) {
+                    Object.defineProperties(ctor.prototype, {
+                        "__debugKind": { get(this: Node) { return formatSyntaxKind(this.kind); } },
+                        "__debugModifierFlags": { get(this: Node) { return formatModifierFlags(getModifierFlagsNoCache(this)); } },
+                        "__debugTransformFlags": { get(this: Node) { return formatTransformFlags(this.transformFlags); } },
+                        "__debugEmitFlags": { get(this: Node) { return formatEmitFlags(getEmitFlags(this)); } },
+                        "__debugGetText": {
+                            value(this: Node, includeTrivia?: boolean) {
+                                if (nodeIsSynthesized(this)) return "";
+                                const parseNode = getParseTreeNode(this);
+                                const sourceFile = parseNode && getSourceFileOfNode(parseNode);
+                                return sourceFile ? getSourceTextOfNodeFromSourceFile(sourceFile, parseNode, includeTrivia) : "";
+                            }
+                        }
+                    });
+                }
+            }
+
+            isDebugInfoEnabled = true;
+        }
     }
 }

src/harness/runner.ts

@@ -222,6 +222,10 @@ if (taskConfigsFolder) {
     }
 }
 else {
+    if (ts.Debug.isDebugging) {
+        ts.Debug.enableDebugInfo();
+    }
+
     runTests(runners);
 }
 if (!runUnitTests) {

src/harness/unittests/printer.ts

@@ -81,63 +81,136 @@ namespace ts {
 
         describe("printNode", () => {
             const printsCorrectly = makePrintsCorrectly("printsNodeCorrectly");
-            let sourceFile: SourceFile;
-            before(() => sourceFile = createSourceFile("source.ts", "", ScriptTarget.ES2015));
-            // tslint:disable boolean-trivia
-            const syntheticNode = createClassDeclaration(
-                undefined,
-                undefined,
-                /*name*/ createIdentifier("C"),
-                undefined,
-                undefined,
-                createNodeArray([
-                    createProperty(
-                        undefined,
+            printsCorrectly("class", {}, printer => printer.printNode(
+                EmitHint.Unspecified,
+                createClassDeclaration(
+                    /*decorators*/ undefined,
+                    /*modifiers*/ undefined,
+                    /*name*/ createIdentifier("C"),
+                    /*typeParameters*/ undefined,
+                    /*heritageClauses*/ undefined,
+                    [createProperty(
+                        /*decorators*/ undefined,
                         createNodeArray([createToken(SyntaxKind.PublicKeyword)]),
                         createIdentifier("prop"),
-                        undefined,
-                        undefined,
-                        undefined
-                    )
-                ])
-            );
+                        /*questionToken*/ undefined,
+                        /*type*/ undefined,
+                        /*initializer*/ undefined
+                    )]
+                ),
+                createSourceFile("source.ts", "", ScriptTarget.ES2015)
+            ));
+
+            printsCorrectly("namespaceExportDeclaration", {}, printer => printer.printNode(
+                EmitHint.Unspecified,
+                createNamespaceExportDeclaration("B"),
+                createSourceFile("source.ts", "", ScriptTarget.ES2015)
+            ));
 
             // https://github.com/Microsoft/TypeScript/issues/15971
-            const classWithOptionalMethodAndProperty = createClassDeclaration(
-                undefined,
-                /* modifiers */ createNodeArray([createToken(SyntaxKind.DeclareKeyword)]),
-                /* name      */ createIdentifier("X"),
-                undefined,
-                undefined,
-                createNodeArray([
-                    createMethod(
-                        undefined,
-                        undefined,
-                        undefined,
-                        /* name          */ createIdentifier("method"),
-                        /* questionToken */ createToken(SyntaxKind.QuestionToken),
-                        undefined,
-                        undefined,
-                        /* type          */ createKeywordTypeNode(SyntaxKind.VoidKeyword),
-                        undefined
+            printsCorrectly("classWithOptionalMethodAndProperty", {}, printer => printer.printNode(
+                EmitHint.Unspecified,
+                createClassDeclaration(
+                    /*decorators*/ undefined,
+                    /*modifiers*/ [createToken(SyntaxKind.DeclareKeyword)],
+                    /*name*/ createIdentifier("X"),
+                    /*typeParameters*/ undefined,
+                    /*heritageClauses*/ undefined,
+                    [
+                        createMethod(
+                            /*decorators*/ undefined,
+                            /*modifiers*/ undefined,
+                            /*asteriskToken*/ undefined,
+                            /*name*/ createIdentifier("method"),
+                            /*questionToken*/ createToken(SyntaxKind.QuestionToken),
+                            /*typeParameters*/ undefined,
+                            [],
+                            /*type*/ createKeywordTypeNode(SyntaxKind.VoidKeyword),
+                            /*body*/ undefined
+                        ),
+                        createProperty(
+                            /*decorators*/ undefined,
+                            /*modifiers*/ undefined,
+                            /*name*/ createIdentifier("property"),
+                            /*questionToken*/ createToken(SyntaxKind.QuestionToken),
+                            /*type*/ createKeywordTypeNode(SyntaxKind.StringKeyword),
+                            /*initializer*/ undefined
+                        ),
+                    ]
+                ),
+                createSourceFile("source.ts", "", ScriptTarget.ES2015)
+            ));
+
+            // https://github.com/Microsoft/TypeScript/issues/15651
+            printsCorrectly("functionTypes", {}, printer => printer.printNode(
+                EmitHint.Unspecified,
+                createTupleTypeNode([
+                    createFunctionTypeNode(
+                        /*typeArguments*/ undefined,
+                        [createParameter(
+                            /*decorators*/ undefined,
+                            /*modifiers*/ undefined,
+                            /*dotDotDotToken*/ undefined,
+                            createIdentifier("args")
+                        )],
+                        createKeywordTypeNode(SyntaxKind.AnyKeyword)
                     ),
-                    createProperty(
-                        undefined,
-                        undefined,
-                        /* name          */ createIdentifier("property"),
-                        /* questionToken */ createToken(SyntaxKind.QuestionToken),
-                        /* type          */ createKeywordTypeNode(SyntaxKind.StringKeyword),
-                        undefined
+                    createFunctionTypeNode(
+                        [createTypeParameterDeclaration("T")],
+                        [createParameter(
+                            /*decorators*/ undefined,
+                            /*modifiers*/ undefined,
+                            /*dotDotDotToken*/ undefined,
+                            createIdentifier("args")
+                        )],
+                        createKeywordTypeNode(SyntaxKind.AnyKeyword)
                     ),
-                ])
-            );
-
-            // tslint:enable boolean-trivia
-            printsCorrectly("class", {}, printer => printer.printNode(EmitHint.Unspecified, syntheticNode, sourceFile));
-
-            printsCorrectly("namespaceExportDeclaration", {}, printer => printer.printNode(EmitHint.Unspecified, createNamespaceExportDeclaration("B"), sourceFile));
-
-            printsCorrectly("classWithOptionalMethodAndProperty", {}, printer => printer.printNode(EmitHint.Unspecified, classWithOptionalMethodAndProperty, sourceFile));
+                    createFunctionTypeNode(
+                        /*typeArguments*/ undefined,
+                        [createParameter(
+                            /*decorators*/ undefined,
+                            /*modifiers*/ undefined,
+                            createToken(SyntaxKind.DotDotDotToken),
+                            createIdentifier("args")
+                        )],
+                        createKeywordTypeNode(SyntaxKind.AnyKeyword)
+                    ),
+                    createFunctionTypeNode(
+                        /*typeArguments*/ undefined,
+                        [createParameter(
+                            /*decorators*/ undefined,
+                            /*modifiers*/ undefined,
+                            /*dotDotDotToken*/ undefined,
+                            createIdentifier("args"),
+                            createToken(SyntaxKind.QuestionToken)
+                        )],
+                        createKeywordTypeNode(SyntaxKind.AnyKeyword)
+                    ),
+                    createFunctionTypeNode(
+                        /*typeArguments*/ undefined,
+                        [createParameter(
+                            /*decorators*/ undefined,
+                            /*modifiers*/ undefined,
+                            /*dotDotDotToken*/ undefined,
+                            createIdentifier("args"),
+                            /*questionToken*/ undefined,
+                            createKeywordTypeNode(SyntaxKind.AnyKeyword)
+                        )],
+                        createKeywordTypeNode(SyntaxKind.AnyKeyword)
+                    ),
+                    createFunctionTypeNode(
+                        /*typeArguments*/ undefined,
+                        [createParameter(
+                            /*decorators*/ undefined,
+                            /*modifiers*/ undefined,
+                            /*dotDotDotToken*/ undefined,
+                            createObjectBindingPattern([])
+                        )],
+                        createKeywordTypeNode(SyntaxKind.AnyKeyword)
+                    ),
+                ]),
+                createSourceFile("source.ts", "", ScriptTarget.ES2015)
+            ));
         });
     });
 }

src/lib/dom.generated.d.ts

@@ -3483,7 +3483,7 @@ interface DragEvent extends MouseEvent {
 
 declare var DragEvent: {
     prototype: DragEvent;
-    new(): DragEvent;
+    new(type: "drag" | "dragend" | "dragenter" | "dragexit" | "dragleave" | "dragover" | "dragstart" | "drop", dragEventInit?: { dataTransfer?: DataTransfer }): DragEvent;
 };
 
 interface DynamicsCompressorNode extends AudioNode {
@@ -8224,6 +8224,7 @@ interface Navigator extends Object, NavigatorID, NavigatorOnLine, NavigatorConte
     readonly serviceWorker: ServiceWorkerContainer;
     readonly webdriver: boolean;
     readonly hardwareConcurrency: number;
+    readonly languages: string[];
     getGamepads(): Gamepad[];
     javaEnabled(): boolean;
     msLaunchUri(uri: string, successCallback?: MSLaunchUriCallback, noHandlerCallback?: MSLaunchUriCallback): void;

tests/baselines/reference/printerApi/printsNodeCorrectly.functionTypes.js

@@ -0,0 +1 @@
+[args => any, <T>(args) => any, (...args) => any, (args?) => any, (args: any) => any, ({}) => any]

tests/baselines/reference/returnInfiniteIntersection.js

@@ -0,0 +1,15 @@
+//// [returnInfiniteIntersection.ts]
+function recursive() {
+    let x = <T>(subkey: T) => recursive();
+    return x as typeof x & { p };
+}
+
+let result = recursive()(1)
+
+
+//// [returnInfiniteIntersection.js]
+function recursive() {
+    var x = function (subkey) { return recursive(); };
+    return x;
+}
+var result = recursive()(1);

tests/baselines/reference/returnInfiniteIntersection.symbols

@@ -0,0 +1,21 @@
+=== tests/cases/compiler/returnInfiniteIntersection.ts ===
+function recursive() {
+>recursive : Symbol(recursive, Decl(returnInfiniteIntersection.ts, 0, 0))
+
+    let x = <T>(subkey: T) => recursive();
+>x : Symbol(x, Decl(returnInfiniteIntersection.ts, 1, 7))
+>T : Symbol(T, Decl(returnInfiniteIntersection.ts, 1, 13))
+>subkey : Symbol(subkey, Decl(returnInfiniteIntersection.ts, 1, 16))
+>T : Symbol(T, Decl(returnInfiniteIntersection.ts, 1, 13))
+>recursive : Symbol(recursive, Decl(returnInfiniteIntersection.ts, 0, 0))
+
+    return x as typeof x & { p };
+>x : Symbol(x, Decl(returnInfiniteIntersection.ts, 1, 7))
+>x : Symbol(x, Decl(returnInfiniteIntersection.ts, 1, 7))
+>p : Symbol(p, Decl(returnInfiniteIntersection.ts, 2, 28))
+}
+
+let result = recursive()(1)
+>result : Symbol(result, Decl(returnInfiniteIntersection.ts, 5, 3))
+>recursive : Symbol(recursive, Decl(returnInfiniteIntersection.ts, 0, 0))
+

tests/baselines/reference/returnInfiniteIntersection.types

@@ -0,0 +1,27 @@
+=== tests/cases/compiler/returnInfiniteIntersection.ts ===
+function recursive() {
+>recursive : () => (<T>(subkey: T) => any & { p: any; }) & { p: any; }
+
+    let x = <T>(subkey: T) => recursive();
+>x : <T>(subkey: T) => any & { p: any; }
+><T>(subkey: T) => recursive() : <T>(subkey: T) => any & { p: any; }
+>T : T
+>subkey : T
+>T : T
+>recursive() : (<T>(subkey: T) => any & { p: any; }) & { p: any; }
+>recursive : () => (<T>(subkey: T) => any & { p: any; }) & { p: any; }
+
+    return x as typeof x & { p };
+>x as typeof x & { p } : (<T>(subkey: T) => any & { p: any; }) & { p: any; }
+>x : <T>(subkey: T) => any & { p: any; }
+>x : <T>(subkey: T) => any & { p: any; }
+>p : any
+}
+
+let result = recursive()(1)
+>result : (<T>(subkey: T) => any & { p: any; }) & { p: any; }
+>recursive()(1) : (<T>(subkey: T) => any & { p: any; }) & { p: any; }
+>recursive() : (<T>(subkey: T) => any & { p: any; }) & { p: any; }
+>recursive : () => (<T>(subkey: T) => any & { p: any; }) & { p: any; }
+>1 : 1
+

tests/baselines/reference/typeFromParamTagForFunction.symbols

@@ -0,0 +1,184 @@
+=== tests/cases/conformance/salsa/node.d.ts ===
+declare function require(id: string): any;
+>require : Symbol(require, Decl(node.d.ts, 0, 0))
+>id : Symbol(id, Decl(node.d.ts, 0, 25))
+
+declare var module: any, exports: any;
+>module : Symbol(module, Decl(node.d.ts, 1, 11))
+>exports : Symbol(exports, Decl(node.d.ts, 1, 24))
+
+=== tests/cases/conformance/salsa/a-ext.js ===
+exports.A = function () {
+>exports : Symbol(A, Decl(a-ext.js, 0, 0))
+>A : Symbol(A, Decl(a-ext.js, 0, 0))
+
+    this.x = 1;
+>x : Symbol((Anonymous function).x, Decl(a-ext.js, 0, 25))
+
+};
+
+=== tests/cases/conformance/salsa/a.js ===
+const { A } = require("./a-ext");
+>A : Symbol(A, Decl(a.js, 0, 7))
+>require : Symbol(require, Decl(node.d.ts, 0, 0))
+>"./a-ext" : Symbol("tests/cases/conformance/salsa/a-ext", Decl(a-ext.js, 0, 0))
+
+/** @param {A} p */
+function a(p) { p.x; }
+>a : Symbol(a, Decl(a.js, 0, 33))
+>p : Symbol(p, Decl(a.js, 3, 11))
+>p.x : Symbol((Anonymous function).x, Decl(a-ext.js, 0, 25))
+>p : Symbol(p, Decl(a.js, 3, 11))
+>x : Symbol((Anonymous function).x, Decl(a-ext.js, 0, 25))
+
+=== tests/cases/conformance/salsa/b-ext.js ===
+exports.B = class {
+>exports : Symbol(B, Decl(b-ext.js, 0, 0))
+>B : Symbol(B, Decl(b-ext.js, 0, 0))
+
+    constructor() {
+        this.x = 1;
+>this.x : Symbol((Anonymous class).x, Decl(b-ext.js, 1, 19))
+>this : Symbol((Anonymous class), Decl(b-ext.js, 0, 11))
+>x : Symbol((Anonymous class).x, Decl(b-ext.js, 1, 19))
+    }
+};
+
+=== tests/cases/conformance/salsa/b.js ===
+const { B } = require("./b-ext");
+>B : Symbol(B, Decl(b.js, 0, 7))
+>require : Symbol(require, Decl(node.d.ts, 0, 0))
+>"./b-ext" : Symbol("tests/cases/conformance/salsa/b-ext", Decl(b-ext.js, 0, 0))
+
+/** @param {B} p */
+function b(p) { p.x; }
+>b : Symbol(b, Decl(b.js, 0, 33))
+>p : Symbol(p, Decl(b.js, 3, 11))
+>p.x : Symbol((Anonymous class).x, Decl(b-ext.js, 1, 19))
+>p : Symbol(p, Decl(b.js, 3, 11))
+>x : Symbol((Anonymous class).x, Decl(b-ext.js, 1, 19))
+
+=== tests/cases/conformance/salsa/c-ext.js ===
+export function C() {
+>C : Symbol(C, Decl(c-ext.js, 0, 0))
+
+    this.x = 1;
+>x : Symbol(C.x, Decl(c-ext.js, 0, 21))
+}
+
+=== tests/cases/conformance/salsa/c.js ===
+const { C } = require("./c-ext");
+>C : Symbol(C, Decl(c.js, 0, 7))
+>require : Symbol(require, Decl(node.d.ts, 0, 0))
+>"./c-ext" : Symbol("tests/cases/conformance/salsa/c-ext", Decl(c-ext.js, 0, 0))
+
+/** @param {C} p */
+function c(p) { p.x; }
+>c : Symbol(c, Decl(c.js, 0, 33))
+>p : Symbol(p, Decl(c.js, 3, 11))
+>p.x : Symbol(C.x, Decl(c-ext.js, 0, 21))
+>p : Symbol(p, Decl(c.js, 3, 11))
+>x : Symbol(C.x, Decl(c-ext.js, 0, 21))
+
+=== tests/cases/conformance/salsa/d-ext.js ===
+export var D = function() {
+>D : Symbol(D, Decl(d-ext.js, 0, 10))
+
+    this.x = 1;
+>x : Symbol(D.x, Decl(d-ext.js, 0, 27))
+
+};
+
+=== tests/cases/conformance/salsa/d.js ===
+const { D } = require("./d-ext");
+>D : Symbol(D, Decl(d.js, 0, 7))
+>require : Symbol(require, Decl(node.d.ts, 0, 0))
+>"./d-ext" : Symbol("tests/cases/conformance/salsa/d-ext", Decl(d-ext.js, 0, 0))
+
+/** @param {D} p */
+function d(p) { p.x; }
+>d : Symbol(d, Decl(d.js, 0, 33))
+>p : Symbol(p, Decl(d.js, 3, 11))
+>p.x : Symbol(D.x, Decl(d-ext.js, 0, 27))
+>p : Symbol(p, Decl(d.js, 3, 11))
+>x : Symbol(D.x, Decl(d-ext.js, 0, 27))
+
+=== tests/cases/conformance/salsa/e-ext.js ===
+export class E {
+>E : Symbol(E, Decl(e-ext.js, 0, 0))
+
+    constructor() {
+        this.x = 1;
+>this.x : Symbol(E.x, Decl(e-ext.js, 1, 19))
+>this : Symbol(E, Decl(e-ext.js, 0, 0))
+>x : Symbol(E.x, Decl(e-ext.js, 1, 19))
+    }
+}
+
+=== tests/cases/conformance/salsa/e.js ===
+const { E } = require("./e-ext");
+>E : Symbol(E, Decl(e.js, 0, 7))
+>require : Symbol(require, Decl(node.d.ts, 0, 0))
+>"./e-ext" : Symbol("tests/cases/conformance/salsa/e-ext", Decl(e-ext.js, 0, 0))
+
+/** @param {E} p */
+function e(p) { p.x; }
+>e : Symbol(e, Decl(e.js, 0, 33))
+>p : Symbol(p, Decl(e.js, 3, 11))
+>p.x : Symbol(E.x, Decl(e-ext.js, 1, 19))
+>p : Symbol(p, Decl(e.js, 3, 11))
+>x : Symbol(E.x, Decl(e-ext.js, 1, 19))
+
+=== tests/cases/conformance/salsa/f.js ===
+var F = function () {
+>F : Symbol(F, Decl(f.js, 0, 3))
+
+    this.x = 1;
+>x : Symbol(F.x, Decl(f.js, 0, 21))
+
+};
+
+/** @param {F} p */
+function f(p) { p.x; }
+>f : Symbol(f, Decl(f.js, 2, 2))
+>p : Symbol(p, Decl(f.js, 5, 11))
+>p.x : Symbol(F.x, Decl(f.js, 0, 21))
+>p : Symbol(p, Decl(f.js, 5, 11))
+>x : Symbol(F.x, Decl(f.js, 0, 21))
+
+=== tests/cases/conformance/salsa/g.js ===
+function G() {
+>G : Symbol(G, Decl(g.js, 0, 0))
+
+    this.x = 1;
+>x : Symbol(G.x, Decl(g.js, 0, 14))
+}
+
+/** @param {G} p */
+function g(p) { p.x; }
+>g : Symbol(g, Decl(g.js, 2, 1))
+>p : Symbol(p, Decl(g.js, 5, 11))
+>p.x : Symbol(G.x, Decl(g.js, 0, 14))
+>p : Symbol(p, Decl(g.js, 5, 11))
+>x : Symbol(G.x, Decl(g.js, 0, 14))
+
+=== tests/cases/conformance/salsa/h.js ===
+class H {
+>H : Symbol(H, Decl(h.js, 0, 0))
+
+    constructor() {
+        this.x = 1;
+>this.x : Symbol(H.x, Decl(h.js, 1, 19))
+>this : Symbol(H, Decl(h.js, 0, 0))
+>x : Symbol(H.x, Decl(h.js, 1, 19))
+    }
+}
+
+/** @param {H} p */
+function h(p) { p.x; }
+>h : Symbol(h, Decl(h.js, 4, 1))
+>p : Symbol(p, Decl(h.js, 7, 11))
+>p.x : Symbol(H.x, Decl(h.js, 1, 19))
+>p : Symbol(p, Decl(h.js, 7, 11))
+>x : Symbol(H.x, Decl(h.js, 1, 19))
+

tests/baselines/reference/typeFromParamTagForFunction.types

@@ -0,0 +1,223 @@
+=== tests/cases/conformance/salsa/node.d.ts ===
+declare function require(id: string): any;
+>require : (id: string) => any
+>id : string
+
+declare var module: any, exports: any;
+>module : any
+>exports : any
+
+=== tests/cases/conformance/salsa/a-ext.js ===
+exports.A = function () {
+>exports.A = function () {    this.x = 1;} : () => void
+>exports.A : any
+>exports : any
+>A : any
+>function () {    this.x = 1;} : () => void
+
+    this.x = 1;
+>this.x = 1 : 1
+>this.x : any
+>this : any
+>x : any
+>1 : 1
+
+};
+
+=== tests/cases/conformance/salsa/a.js ===
+const { A } = require("./a-ext");
+>A : () => void
+>require("./a-ext") : typeof "tests/cases/conformance/salsa/a-ext"
+>require : (id: string) => any
+>"./a-ext" : "./a-ext"
+
+/** @param {A} p */
+function a(p) { p.x; }
+>a : (p: { x: number; }) => void
+>p : { x: number; }
+>p.x : number
+>p : { x: number; }
+>x : number
+
+=== tests/cases/conformance/salsa/b-ext.js ===
+exports.B = class {
+>exports.B = class {    constructor() {        this.x = 1;    }} : typeof (Anonymous class)
+>exports.B : any
+>exports : any
+>B : any
+>class {    constructor() {        this.x = 1;    }} : typeof (Anonymous class)
+
+    constructor() {
+        this.x = 1;
+>this.x = 1 : 1
+>this.x : number
+>this : this
+>x : number
+>1 : 1
+    }
+};
+
+=== tests/cases/conformance/salsa/b.js ===
+const { B } = require("./b-ext");
+>B : typeof (Anonymous class)
+>require("./b-ext") : typeof "tests/cases/conformance/salsa/b-ext"
+>require : (id: string) => any
+>"./b-ext" : "./b-ext"
+
+/** @param {B} p */
+function b(p) { p.x; }
+>b : (p: (Anonymous class)) => void
+>p : (Anonymous class)
+>p.x : number
+>p : (Anonymous class)
+>x : number
+
+=== tests/cases/conformance/salsa/c-ext.js ===
+export function C() {
+>C : () => void
+
+    this.x = 1;
+>this.x = 1 : 1
+>this.x : any
+>this : any
+>x : any
+>1 : 1
+}
+
+=== tests/cases/conformance/salsa/c.js ===
+const { C } = require("./c-ext");
+>C : () => void
+>require("./c-ext") : typeof "tests/cases/conformance/salsa/c-ext"
+>require : (id: string) => any
+>"./c-ext" : "./c-ext"
+
+/** @param {C} p */
+function c(p) { p.x; }
+>c : (p: { x: number; }) => void
+>p : { x: number; }
+>p.x : number
+>p : { x: number; }
+>x : number
+
+=== tests/cases/conformance/salsa/d-ext.js ===
+export var D = function() {
+>D : () => void
+>function() {    this.x = 1;} : () => void
+
+    this.x = 1;
+>this.x = 1 : 1
+>this.x : any
+>this : any
+>x : any
+>1 : 1
+
+};
+
+=== tests/cases/conformance/salsa/d.js ===
+const { D } = require("./d-ext");
+>D : () => void
+>require("./d-ext") : typeof "tests/cases/conformance/salsa/d-ext"
+>require : (id: string) => any
+>"./d-ext" : "./d-ext"
+
+/** @param {D} p */
+function d(p) { p.x; }
+>d : (p: { x: number; }) => void
+>p : { x: number; }
+>p.x : number
+>p : { x: number; }
+>x : number
+
+=== tests/cases/conformance/salsa/e-ext.js ===
+export class E {
+>E : E
+
+    constructor() {
+        this.x = 1;
+>this.x = 1 : 1
+>this.x : number
+>this : this
+>x : number
+>1 : 1
+    }
+}
+
+=== tests/cases/conformance/salsa/e.js ===
+const { E } = require("./e-ext");
+>E : typeof E
+>require("./e-ext") : typeof "tests/cases/conformance/salsa/e-ext"
+>require : (id: string) => any
+>"./e-ext" : "./e-ext"
+
+/** @param {E} p */
+function e(p) { p.x; }
+>e : (p: E) => void
+>p : E
+>p.x : number
+>p : E
+>x : number
+
+=== tests/cases/conformance/salsa/f.js ===
+var F = function () {
+>F : () => void
+>function () {    this.x = 1;} : () => void
+
+    this.x = 1;
+>this.x = 1 : 1
+>this.x : any
+>this : any
+>x : any
+>1 : 1
+
+};
+
+/** @param {F} p */
+function f(p) { p.x; }
+>f : (p: { x: number; }) => void
+>p : { x: number; }
+>p.x : number
+>p : { x: number; }
+>x : number
+
+=== tests/cases/conformance/salsa/g.js ===
+function G() {
+>G : () => void
+
+    this.x = 1;
+>this.x = 1 : 1
+>this.x : any
+>this : any
+>x : any
+>1 : 1
+}
+
+/** @param {G} p */
+function g(p) { p.x; }
+>g : (p: { x: number; }) => void
+>p : { x: number; }
+>p.x : number
+>p : { x: number; }
+>x : number
+
+=== tests/cases/conformance/salsa/h.js ===
+class H {
+>H : H
+
+    constructor() {
+        this.x = 1;
+>this.x = 1 : 1
+>this.x : number
+>this : this
+>x : number
+>1 : 1
+    }
+}
+
+/** @param {H} p */
+function h(p) { p.x; }
+>h : (p: H) => void
+>p : H
+>p.x : number
+>p : H
+>x : number
+

tests/cases/compiler/returnInfiniteIntersection.ts

@@ -0,0 +1,6 @@
+function recursive() {
+    let x = <T>(subkey: T) => recursive();
+    return x as typeof x & { p };
+}
+
+let result = recursive()(1)

tests/cases/conformance/salsa/typeFromParamTagForFunction.ts

@@ -0,0 +1,92 @@
+// @allowJs: true
+// @checkJs: true
+// @noEmit: true
+// @module: commonjs
+// @filename: node.d.ts
+declare function require(id: string): any;
+declare var module: any, exports: any;
+
+// @filename: a-ext.js
+exports.A = function () {
+    this.x = 1;
+};
+
+// @filename: a.js
+const { A } = require("./a-ext");
+
+/** @param {A} p */
+function a(p) { p.x; }
+
+// @filename: b-ext.js
+exports.B = class {
+    constructor() {
+        this.x = 1;
+    }
+};
+
+// @filename: b.js
+const { B } = require("./b-ext");
+
+/** @param {B} p */
+function b(p) { p.x; }
+
+// @filename: c-ext.js
+export function C() {
+    this.x = 1;
+}
+
+// @filename: c.js
+const { C } = require("./c-ext");
+
+/** @param {C} p */
+function c(p) { p.x; }
+
+// @filename: d-ext.js
+export var D = function() {
+    this.x = 1;
+};
+
+// @filename: d.js
+const { D } = require("./d-ext");
+
+/** @param {D} p */
+function d(p) { p.x; }
+
+// @filename: e-ext.js
+export class E {
+    constructor() {
+        this.x = 1;
+    }
+}
+
+// @filename: e.js
+const { E } = require("./e-ext");
+
+/** @param {E} p */
+function e(p) { p.x; }
+
+// @filename: f.js
+var F = function () {
+    this.x = 1;
+};
+
+/** @param {F} p */
+function f(p) { p.x; }
+
+// @filename: g.js
+function G() {
+    this.x = 1;
+}
+
+/** @param {G} p */
+function g(p) { p.x; }
+
+// @filename: h.js
+class H {
+    constructor() {
+        this.x = 1;
+    }
+}
+
+/** @param {H} p */
+function h(p) { p.x; }