Merge branch 'master' into sourceMapDestructuring

Jakefile.js

@@ -924,7 +924,8 @@ function lintFileAsync(options, path, cb) {
 var lintTargets = compilerSources
     .concat(harnessCoreSources)
     .concat(serverCoreSources)
-    .concat(scriptSources);
+    .concat(scriptSources)
+    .concat([path.join(servicesDirectory, "services.ts")]);
 
 desc("Runs tslint on the compiler sources");
 task("lint", ["build-rules"], function() {

doc/README.md

@@ -0,0 +1,7 @@
+This directory contains miscellaneous documentation such as the TypeScript language specification and logo.
+If you are looking for more introductory material, you might want to take a look at the [TypeScript Handbook](https://github.com/Microsoft/TypeScript-Handbook).
+
+# Spec Contributions
+
+The specification is first authored as a Microsoft Word (docx) file and then generated into Markdown and PDF formats.
+Due to the binary format of docx files, and the merging difficulties that may come with it, it is preferred that any suggestions or problems found in the spec should be [filed as issues](https://github.com/Microsoft/TypeScript/issues/new) rather than sent as pull requests.

src/compiler/binder.ts

@@ -1499,10 +1499,7 @@ namespace ts {
 
             // If this is a property-parameter, then also declare the property symbol into the
             // containing class.
-            if (node.flags & NodeFlags.AccessibilityModifier &&
-                node.parent.kind === SyntaxKind.Constructor &&
-                isClassLike(node.parent.parent)) {
-
+            if (isParameterPropertyDeclaration(node)) {
                 const classDeclaration = <ClassLikeDeclaration>node.parent.parent;
                 declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes);
             }

src/compiler/checker.ts

@@ -67,6 +67,7 @@ namespace ts {
             // The language service will always care about the narrowed type of a symbol, because that is
             // the type the language says the symbol should have.
             getTypeOfSymbolAtLocation: getNarrowedTypeOfSymbol,
+            getSymbolsOfParameterPropertyDeclaration,
             getDeclaredTypeOfSymbol,
             getPropertiesOfType,
             getPropertyOfType,
@@ -430,6 +431,26 @@ namespace ts {
             // return undefined if we can't find a symbol.
         }
 
+        /**
+         * Get symbols that represent parameter-property-declaration as parameter and as property declaration
+         * @param parameter a parameterDeclaration node
+         * @param parameterName a name of the parameter to get the symbols for.
+         * @return a tuple of two symbols 
+         */
+        function getSymbolsOfParameterPropertyDeclaration(parameter: ParameterDeclaration, parameterName: string): [Symbol, Symbol] {
+            const constructoDeclaration = parameter.parent;
+            const classDeclaration = parameter.parent.parent;
+
+            const parameterSymbol = getSymbol(constructoDeclaration.locals, parameterName, SymbolFlags.Value);
+            const propertySymbol = getSymbol(classDeclaration.symbol.members, parameterName, SymbolFlags.Value);
+
+            if (parameterSymbol && propertySymbol) {
+                return [parameterSymbol, propertySymbol];
+            }
+
+            Debug.fail("There should exist two symbols, one as property declaration and one as parameter declaration");
+        }
+
         function isBlockScopedNameDeclaredBeforeUse(declaration: Declaration, usage: Node): boolean {
             const declarationFile = getSourceFileOfNode(declaration);
             const useFile = getSourceFileOfNode(usage);
@@ -819,15 +840,6 @@ namespace ts {
             return resolveESModuleSymbol(resolveExternalModuleName(node, moduleSpecifier), moduleSpecifier);
         }
 
-        function getMemberOfModuleVariable(moduleSymbol: Symbol, name: string): Symbol {
-            if (moduleSymbol.flags & SymbolFlags.Variable) {
-                const typeAnnotation = (<VariableDeclaration>moduleSymbol.valueDeclaration).type;
-                if (typeAnnotation) {
-                    return getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name);
-                }
-            }
-        }
-
         // This function creates a synthetic symbol that combines the value side of one symbol with the
         // type/namespace side of another symbol. Consider this example:
         //
@@ -1063,7 +1075,6 @@ namespace ts {
             }
 
             const moduleReferenceLiteral = <LiteralExpression>moduleReferenceExpression;
-            const searchPath = getDirectoryPath(getSourceFile(location).fileName);
 
             // Module names are escaped in our symbol table.  However, string literal values aren't.
             // Escape the name in the "require(...)" clause to ensure we find the right symbol.
@@ -2183,65 +2194,15 @@ namespace ts {
         }
 
         function isDeclarationVisible(node: Declaration): boolean {
-            function getContainingExternalModule(node: Node) {
-                for (; node; node = node.parent) {
-                    if (node.kind === SyntaxKind.ModuleDeclaration) {
-                        if ((<ModuleDeclaration>node).name.kind === SyntaxKind.StringLiteral) {
-                            return node;
-                        }
-                    }
-                    else if (node.kind === SyntaxKind.SourceFile) {
-                        return isExternalOrCommonJsModule(<SourceFile>node) ? node : undefined;
-                    }
+            if (node) {
+                const links = getNodeLinks(node);
+                if (links.isVisible === undefined) {
+                    links.isVisible = !!determineIfDeclarationIsVisible();
                 }
-                Debug.fail("getContainingModule cant reach here");
+                return links.isVisible;
             }
 
-            function isUsedInExportAssignment(node: Node) {
-                // Get source File and see if it is external module and has export assigned symbol
-                const externalModule = getContainingExternalModule(node);
-                let exportAssignmentSymbol: Symbol;
-                let resolvedExportSymbol: Symbol;
-                if (externalModule) {
-                    // This is export assigned symbol node
-                    const externalModuleSymbol = getSymbolOfNode(externalModule);
-                    exportAssignmentSymbol = getExportAssignmentSymbol(externalModuleSymbol);
-                    const symbolOfNode = getSymbolOfNode(node);
-                    if (isSymbolUsedInExportAssignment(symbolOfNode)) {
-                        return true;
-                    }
-
-                    // if symbolOfNode is alias declaration, resolve the symbol declaration and check
-                    if (symbolOfNode.flags & SymbolFlags.Alias) {
-                        return isSymbolUsedInExportAssignment(resolveAlias(symbolOfNode));
-                    }
-                }
-
-                // Check if the symbol is used in export assignment
-                function isSymbolUsedInExportAssignment(symbol: Symbol) {
-                    if (exportAssignmentSymbol === symbol) {
-                        return true;
-                    }
-
-                    if (exportAssignmentSymbol && !!(exportAssignmentSymbol.flags & SymbolFlags.Alias)) {
-                        // if export assigned symbol is alias declaration, resolve the alias
-                        resolvedExportSymbol = resolvedExportSymbol || resolveAlias(exportAssignmentSymbol);
-                        if (resolvedExportSymbol === symbol) {
-                            return true;
-                        }
-
-                        // Container of resolvedExportSymbol is visible
-                        return forEach(resolvedExportSymbol.declarations, (current: Node) => {
-                            while (current) {
-                                if (current === node) {
-                                    return true;
-                                }
-                                current = current.parent;
-                            }
-                        });
-                    }
-                }
-            }
+            return false;
 
             function determineIfDeclarationIsVisible() {
                 switch (node.kind) {
@@ -2320,14 +2281,6 @@ namespace ts {
                         Debug.fail("isDeclarationVisible unknown: SyntaxKind: " + node.kind);
                 }
             }
-
-            if (node) {
-                const links = getNodeLinks(node);
-                if (links.isVisible === undefined) {
-                    links.isVisible = !!determineIfDeclarationIsVisible();
-                }
-                return links.isVisible;
-            }
         }
 
         function collectLinkedAliases(node: Identifier): Node[] {
@@ -3373,14 +3326,6 @@ namespace ts {
             }
         }
 
-        function addInheritedSignatures(signatures: Signature[], baseSignatures: Signature[]) {
-            if (baseSignatures) {
-                for (const signature of baseSignatures) {
-                    signatures.push(signature);
-                }
-            }
-        }
-
         function resolveDeclaredMembers(type: InterfaceType): InterfaceTypeWithDeclaredMembers {
             if (!(<InterfaceTypeWithDeclaredMembers>type).declaredProperties) {
                 const symbol = type.symbol;
@@ -3507,7 +3452,7 @@ namespace ts {
 
         function findMatchingSignature(signatureList: Signature[], signature: Signature, partialMatch: boolean, ignoreReturnTypes: boolean): Signature {
             for (const s of signatureList) {
-                if (compareSignatures(s, signature, partialMatch, ignoreReturnTypes, compareTypes)) {
+                if (compareSignaturesIdentical(s, signature, partialMatch, ignoreReturnTypes, compareTypesIdentical)) {
                     return s;
                 }
             }
@@ -3768,11 +3713,14 @@ namespace ts {
         function createUnionOrIntersectionProperty(containingType: UnionOrIntersectionType, name: string): Symbol {
             const types = containingType.types;
             let props: Symbol[];
+            // Flags we want to propagate to the result if they exist in all source symbols
+            let commonFlags = (containingType.flags & TypeFlags.Intersection) ? SymbolFlags.Optional : SymbolFlags.None;
             for (const current of types) {
                 const type = getApparentType(current);
                 if (type !== unknownType) {
                     const prop = getPropertyOfType(type, name);
                     if (prop && !(getDeclarationFlagsFromSymbol(prop) & (NodeFlags.Private | NodeFlags.Protected))) {
+                        commonFlags &= prop.flags;
                         if (!props) {
                             props = [prop];
                         }
@@ -3800,7 +3748,12 @@ namespace ts {
                 }
                 propTypes.push(getTypeOfSymbol(prop));
             }
-            const result = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient | SymbolFlags.SyntheticProperty, name);
+            const result = <TransientSymbol>createSymbol(
+                SymbolFlags.Property |
+                SymbolFlags.Transient |
+                SymbolFlags.SyntheticProperty |
+                commonFlags,
+                name);
             result.containingType = containingType;
             result.declarations = declarations;
             result.type = containingType.flags & TypeFlags.Union ? getUnionType(propTypes) : getIntersectionType(propTypes);
@@ -3861,25 +3814,6 @@ namespace ts {
         function getSignaturesOfType(type: Type, kind: SignatureKind): Signature[] {
             return getSignaturesOfStructuredType(getApparentType(type), kind);
         }
-
-        function typeHasConstructSignatures(type: Type): boolean {
-            const apparentType = getApparentType(type);
-            if (apparentType.flags & (TypeFlags.ObjectType | TypeFlags.Union)) {
-                const resolved = resolveStructuredTypeMembers(<ObjectType>type);
-                return resolved.constructSignatures.length > 0;
-            }
-            return false;
-        }
-
-        function typeHasCallOrConstructSignatures(type: Type): boolean {
-            const apparentType = getApparentType(type);
-            if (apparentType.flags & TypeFlags.StructuredType) {
-                const resolved = resolveStructuredTypeMembers(<ObjectType>type);
-                return resolved.callSignatures.length > 0 || resolved.constructSignatures.length > 0;
-            }
-            return false;
-        }
-
         function getIndexTypeOfStructuredType(type: Type, kind: IndexKind): Type {
             if (type.flags & TypeFlags.StructuredType) {
                 const resolved = resolveStructuredTypeMembers(<ObjectType>type);
@@ -4381,10 +4315,6 @@ namespace ts {
             return getTypeOfGlobalSymbol(getGlobalTypeSymbol(name), arity);
         }
 
-        function tryGetGlobalType(name: string, arity = 0): ObjectType {
-            return getTypeOfGlobalSymbol(getGlobalSymbol(name, SymbolFlags.Type, /*diagnostic*/ undefined), arity);
-        }
-
         /**
          * Returns a type that is inside a namespace at the global scope, e.g.
          * getExportedTypeFromNamespace('JSX', 'Element') returns the JSX.Element type
@@ -4959,7 +4889,7 @@ namespace ts {
             return checkTypeRelatedTo(source, target, identityRelation, /*errorNode*/ undefined);
         }
 
-        function compareTypes(source: Type, target: Type): Ternary {
+        function compareTypesIdentical(source: Type, target: Type): Ternary {
             return checkTypeRelatedTo(source, target, identityRelation, /*errorNode*/ undefined) ? Ternary.True : Ternary.False;
         }
 
@@ -4979,10 +4909,96 @@ namespace ts {
             return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain);
         }
 
-        function isSignatureAssignableTo(source: Signature, target: Signature): boolean {
-            const sourceType = getOrCreateTypeFromSignature(source);
-            const targetType = getOrCreateTypeFromSignature(target);
-            return checkTypeRelatedTo(sourceType, targetType, assignableRelation, /*errorNode*/ undefined);
+        /**
+         * See signatureRelatedTo, compareSignaturesIdentical
+         */
+        function isSignatureAssignableTo(source: Signature, target: Signature, ignoreReturnTypes: boolean): boolean {
+            // TODO (drosen): De-duplicate code between related functions.
+            if (source === target) {
+                return true;
+            }
+            if (!target.hasRestParameter && source.minArgumentCount > target.parameters.length) {
+                return false;
+            }
+
+            // Spec 1.0 Section 3.8.3 & 3.8.4:
+            // M and N (the signatures) are instantiated using type Any as the type argument for all type parameters declared by M and N
+            source = getErasedSignature(source);
+            target = getErasedSignature(target);
+
+            const sourceMax = getNumNonRestParameters(source);
+            const targetMax = getNumNonRestParameters(target);
+            const checkCount = getNumParametersToCheckForSignatureRelatability(source, sourceMax, target, targetMax);
+            for (let i = 0; i < checkCount; i++) {
+                const s = i < sourceMax ? getTypeOfSymbol(source.parameters[i]) : getRestTypeOfSignature(source);
+                const t = i < targetMax ? getTypeOfSymbol(target.parameters[i]) : getRestTypeOfSignature(target);
+                const related = isTypeAssignableTo(t, s) || isTypeAssignableTo(s, t);
+                if (!related) {
+                    return false;
+                }
+            }
+
+            if (!ignoreReturnTypes) {
+                const targetReturnType = getReturnTypeOfSignature(target);
+                if (targetReturnType === voidType) {
+                    return true;
+                }
+                const sourceReturnType = getReturnTypeOfSignature(source);
+
+                // The following block preserves behavior forbidding boolean returning functions from being assignable to type guard returning functions
+                if (targetReturnType.flags & TypeFlags.PredicateType && (targetReturnType as PredicateType).predicate.kind === TypePredicateKind.Identifier) {
+                    if (!(sourceReturnType.flags & TypeFlags.PredicateType)) {
+                        return false;
+                    }
+                }
+
+                return isTypeAssignableTo(sourceReturnType, targetReturnType);
+            }
+
+            return true;
+        }
+
+        function isImplementationCompatibleWithOverload(implementation: Signature, overload: Signature): boolean {
+            const erasedSource = getErasedSignature(implementation);
+            const erasedTarget = getErasedSignature(overload);
+
+            // First see if the return types are compatible in either direction.
+            const sourceReturnType = getReturnTypeOfSignature(erasedSource);
+            const targetReturnType = getReturnTypeOfSignature(erasedTarget);
+            if (targetReturnType === voidType
+                || checkTypeRelatedTo(targetReturnType, sourceReturnType, assignableRelation, /*errorNode*/ undefined)
+                || checkTypeRelatedTo(sourceReturnType, targetReturnType, assignableRelation, /*errorNode*/ undefined)) {
+
+                return isSignatureAssignableTo(erasedSource, erasedTarget, /*ignoreReturnTypes*/ true);
+            }
+
+            return false;
+        }
+
+        function getNumNonRestParameters(signature: Signature) {
+            const numParams = signature.parameters.length;
+            return signature.hasRestParameter ?
+                numParams - 1 :
+                numParams;
+        }
+
+        function getNumParametersToCheckForSignatureRelatability(source: Signature, sourceNonRestParamCount: number, target: Signature, targetNonRestParamCount: number) {
+            if (source.hasRestParameter === target.hasRestParameter) {
+                if (source.hasRestParameter) {
+                    // If both have rest parameters, get the max and add 1 to
+                    // compensate for the rest parameter.
+                    return Math.max(sourceNonRestParamCount, targetNonRestParamCount) + 1;
+                }
+                else {
+                    return Math.min(sourceNonRestParamCount, targetNonRestParamCount);
+                }
+            }
+            else {
+                // Return the count for whichever signature doesn't have rest parameters.
+                return source.hasRestParameter ?
+                    targetNonRestParamCount :
+                    sourceNonRestParamCount;
+            }
         }
 
         /**
@@ -5066,6 +5082,11 @@ namespace ts {
                 if (source === undefinedType) return Ternary.True;
                 if (source === nullType && target !== undefinedType) return Ternary.True;
                 if (source.flags & TypeFlags.Enum && target === numberType) return Ternary.True;
+                if (source.flags & TypeFlags.Enum && target.flags & TypeFlags.Enum) {
+                    if (result = enumRelatedTo(source, target)) {
+                        return result;
+                    }
+                }
                 if (source.flags & TypeFlags.StringLiteral && target === stringType) return Ternary.True;
                 if (relation === assignableRelation) {
                     if (isTypeAny(source)) return Ternary.True;
@@ -5528,32 +5549,24 @@ namespace ts {
                 if (target === anyFunctionType || source === anyFunctionType) {
                     return Ternary.True;
                 }
+
                 const sourceSignatures = getSignaturesOfType(source, kind);
                 const targetSignatures = getSignaturesOfType(target, kind);
+                if (kind === SignatureKind.Construct && sourceSignatures.length && targetSignatures.length &&
+                    isAbstractConstructorType(source) && !isAbstractConstructorType(target)) {
+                    // An abstract constructor type is not assignable to a non-abstract constructor type
+                    // as it would otherwise be possible to new an abstract class. Note that the assignablity
+                    // check we perform for an extends clause excludes construct signatures from the target,
+                    // so this check never proceeds.
+                    if (reportErrors) {
+                        reportError(Diagnostics.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type);
+                    }
+                    return Ternary.False;
+                }
+
                 let result = Ternary.True;
                 const saveErrorInfo = errorInfo;
 
-
-
-                if (kind === SignatureKind.Construct) {
-                    // Only want to compare the construct signatures for abstractness guarantees.
-
-                    // Because the "abstractness" of a class is the same across all construct signatures
-                    // (internally we are checking the corresponding declaration), it is enough to perform
-                    // the check and report an error once over all pairs of source and target construct signatures.
-                    //
-                    // sourceSig and targetSig are (possibly) undefined.
-                    //
-                    // Note that in an extends-clause, targetSignatures is stripped, so the check never proceeds.
-                    const sourceSig = sourceSignatures[0];
-                    const targetSig = targetSignatures[0];
-
-                    result &= abstractSignatureRelatedTo(source, sourceSig, target, targetSig);
-                    if (result !== Ternary.True) {
-                        return result;
-                    }
-                }
-
                 outer: for (const t of targetSignatures) {
                     if (!t.hasStringLiterals || target.flags & TypeFlags.FromSignature) {
                         // Only elaborate errors from the first failure
@@ -5569,7 +5582,7 @@ namespace ts {
                                 shouldElaborateErrors = false;
                             }
                         }
-                        // don't elaborate the primitive apparent types (like Number) 
+                        // don't elaborate the primitive apparent types (like Number)
                         // because the actual primitives will have already been reported.
                         if (shouldElaborateErrors && !isPrimitiveApparentType(source)) {
                             reportError(Diagnostics.Type_0_provides_no_match_for_the_signature_1,
@@ -5580,43 +5593,13 @@ namespace ts {
                     }
                 }
                 return result;
-
-                function abstractSignatureRelatedTo(source: Type, sourceSig: Signature, target: Type, targetSig: Signature) {
-                    if (sourceSig && targetSig) {
-
-                        const sourceDecl = source.symbol && getClassLikeDeclarationOfSymbol(source.symbol);
-                        const targetDecl = target.symbol && getClassLikeDeclarationOfSymbol(target.symbol);
-
-                        if (!sourceDecl) {
-                            // If the source object isn't itself a class declaration, it can be freely assigned, regardless
-                            // of whether the constructed object is abstract or not.
-                            return Ternary.True;
-                        }
-
-                        const sourceErasedSignature = getErasedSignature(sourceSig);
-                        const targetErasedSignature = getErasedSignature(targetSig);
-
-                        const sourceReturnType = sourceErasedSignature && getReturnTypeOfSignature(sourceErasedSignature);
-                        const targetReturnType = targetErasedSignature && getReturnTypeOfSignature(targetErasedSignature);
-
-                        const sourceReturnDecl = sourceReturnType && sourceReturnType.symbol && getClassLikeDeclarationOfSymbol(sourceReturnType.symbol);
-                        const targetReturnDecl = targetReturnType && targetReturnType.symbol && getClassLikeDeclarationOfSymbol(targetReturnType.symbol);
-                        const sourceIsAbstract = sourceReturnDecl && sourceReturnDecl.flags & NodeFlags.Abstract;
-                        const targetIsAbstract = targetReturnDecl && targetReturnDecl.flags & NodeFlags.Abstract;
-
-                        if (sourceIsAbstract && !(targetIsAbstract && targetDecl)) {
-                            // if target isn't a class-declaration type, then it can be new'd, so we forbid the assignment.
-                            if (reportErrors) {
-                                reportError(Diagnostics.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type);
-                            }
-                            return Ternary.False;
-                        }
-                    }
-                    return Ternary.True;
-                }
             }
 
+            /**
+             * See signatureAssignableTo, signatureAssignableTo
+             */
             function signatureRelatedTo(source: Signature, target: Signature, reportErrors: boolean): Ternary {
+                // TODO (drosen): De-duplicate code between related functions.
                 if (source === target) {
                     return Ternary.True;
                 }
@@ -5668,10 +5651,12 @@ namespace ts {
                 }
 
                 const targetReturnType = getReturnTypeOfSignature(target);
-                if (targetReturnType === voidType) return result;
+                if (targetReturnType === voidType) {
+                    return result;
+                }
                 const sourceReturnType = getReturnTypeOfSignature(source);
 
-                // The follow block preserves old behavior forbidding boolean returning functions from being assignable to type guard returning functions
+                // The following block preserves behavior forbidding boolean returning functions from being assignable to type guard returning functions
                 if (targetReturnType.flags & TypeFlags.PredicateType && (targetReturnType as PredicateType).predicate.kind === TypePredicateKind.Identifier) {
                     if (!(sourceReturnType.flags & TypeFlags.PredicateType)) {
                         if (reportErrors) {
@@ -5692,7 +5677,7 @@ namespace ts {
                 }
                 let result = Ternary.True;
                 for (let i = 0, len = sourceSignatures.length; i < len; ++i) {
-                    const related = compareSignatures(sourceSignatures[i], targetSignatures[i], /*partialMatch*/ false, /*ignoreReturnTypes*/ false, isRelatedTo);
+                    const related = compareSignaturesIdentical(sourceSignatures[i], targetSignatures[i], /*partialMatch*/ false, /*ignoreReturnTypes*/ false, isRelatedTo);
                     if (!related) {
                         return Ternary.False;
                     }
@@ -5780,6 +5765,41 @@ namespace ts {
                 }
                 return Ternary.False;
             }
+
+            function enumRelatedTo(source: Type, target: Type) {
+                if (source.symbol.name !== target.symbol.name ||
+                    source.symbol.flags & SymbolFlags.ConstEnum ||
+                    target.symbol.flags & SymbolFlags.ConstEnum) {
+                    return Ternary.False;
+                }
+                const targetEnumType = getTypeOfSymbol(target.symbol);
+                for (const property of getPropertiesOfType(getTypeOfSymbol(source.symbol))) {
+                    if (property.flags & SymbolFlags.EnumMember) {
+                        const targetProperty = getPropertyOfType(targetEnumType, property.name);
+                        if (!targetProperty || !(targetProperty.flags & SymbolFlags.EnumMember)) {
+                            reportError(Diagnostics.Property_0_is_missing_in_type_1,
+                                property.name,
+                                typeToString(target, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType));
+                            return Ternary.False;
+                        }
+                    }
+                }
+                return Ternary.True;
+            }
+        }
+
+        // Return true if the given type is the constructor type for an abstract class
+        function isAbstractConstructorType(type: Type) {
+            if (type.flags & TypeFlags.Anonymous) {
+                const symbol = type.symbol;
+                if (symbol && symbol.flags & SymbolFlags.Class) {
+                    const declaration = getClassLikeDeclarationOfSymbol(symbol);
+                    if (declaration && declaration.flags & NodeFlags.Abstract) {
+                        return true;
+                    }
+                }
+            }
+            return false;
         }
 
         // Return true if the given type is part of a deeply nested chain of generic instantiations. We consider this to be the case
@@ -5804,7 +5824,7 @@ namespace ts {
         }
 
         function isPropertyIdenticalTo(sourceProp: Symbol, targetProp: Symbol): boolean {
-            return compareProperties(sourceProp, targetProp, compareTypes) !== Ternary.False;
+            return compareProperties(sourceProp, targetProp, compareTypesIdentical) !== Ternary.False;
         }
 
         function compareProperties(sourceProp: Symbol, targetProp: Symbol, compareTypes: (source: Type, target: Type) => Ternary): Ternary {
@@ -5851,7 +5871,11 @@ namespace ts {
             return false;
         }
 
-        function compareSignatures(source: Signature, target: Signature, partialMatch: boolean, ignoreReturnTypes: boolean, compareTypes: (s: Type, t: Type) => Ternary): Ternary {
+        /**
+         * See signatureRelatedTo, compareSignaturesIdentical
+         */
+        function compareSignaturesIdentical(source: Signature, target: Signature, partialMatch: boolean, ignoreReturnTypes: boolean, compareTypes: (s: Type, t: Type) => Ternary): Ternary {
+            // TODO (drosen): De-duplicate code between related functions.
             if (source === target) {
                 return Ternary.True;
             }
@@ -6148,12 +6172,8 @@ namespace ts {
         }
 
         function createInferenceContext(typeParameters: TypeParameter[], inferUnionTypes: boolean): InferenceContext {
-            const inferences: TypeInferences[] = [];
-            for (const unused of typeParameters) {
-                inferences.push({
-                    primary: undefined, secondary: undefined, isFixed: false
-                });
-            }
+            const inferences = map(typeParameters, createTypeInferencesObject);
+
             return {
                 typeParameters,
                 inferUnionTypes,
@@ -6162,6 +6182,14 @@ namespace ts {
             };
         }
 
+        function createTypeInferencesObject(): TypeInferences {
+            return {
+                primary: undefined,
+                secondary: undefined,
+                isFixed: false,
+            };
+        }
+
         function inferTypes(context: InferenceContext, source: Type, target: Type) {
             let sourceStack: Type[];
             let targetStack: Type[];
@@ -6432,10 +6460,6 @@ namespace ts {
             return context.inferredTypes;
         }
 
-        function hasAncestor(node: Node, kind: SyntaxKind): boolean {
-            return getAncestor(node, kind) !== undefined;
-        }
-
         // EXPRESSION TYPE CHECKING
 
         function getResolvedSymbol(node: Identifier): Symbol {
@@ -7058,17 +7082,14 @@ namespace ts {
 
         function checkSuperExpression(node: Node): Type {
             const isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).expression === node;
-            const classDeclaration = getContainingClass(node);
-            const classType = classDeclaration && <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration));
-            const baseClassType = classType && getBaseTypes(classType)[0];
 
-            let container = getSuperContainer(node, /*includeFunctions*/ true);
+            let container = getSuperContainer(node, /*stopOnFunctions*/ true);
             let needToCaptureLexicalThis = false;
 
             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, /*includeFunctions*/ true);
+                    container = getSuperContainer(container, /*stopOnFunctions*/ true);
                     needToCaptureLexicalThis = languageVersion < ScriptTarget.ES6;
                 }
             }
@@ -7076,43 +7097,66 @@ namespace ts {
             const canUseSuperExpression = isLegalUsageOfSuperExpression(container);
             let nodeCheckFlag: NodeCheckFlags = 0;
 
-            // always set NodeCheckFlags for 'super' expression node
-            if (canUseSuperExpression) {
-                if ((container.flags & NodeFlags.Static) || isCallExpression) {
-                    nodeCheckFlag = NodeCheckFlags.SuperStatic;
-                }
-                else {
-                    nodeCheckFlag = NodeCheckFlags.SuperInstance;
-                }
-
-                getNodeLinks(node).flags |= nodeCheckFlag;
-
-                if (needToCaptureLexicalThis) {
-                    // call expressions are allowed only in constructors so they should always capture correct 'this'
-                    // super property access expressions can also appear in arrow functions -
-                    // in this case they should also use correct lexical this
-                    captureLexicalThis(node.parent, container);
-                }
-            }
-
-            if (!baseClassType) {
-                if (!classDeclaration || !getClassExtendsHeritageClauseElement(classDeclaration)) {
-                    error(node, Diagnostics.super_can_only_be_referenced_in_a_derived_class);
-                }
-                return unknownType;
-            }
-
             if (!canUseSuperExpression) {
-                if (container && container.kind === SyntaxKind.ComputedPropertyName) {
+                // issue more specific error if super is used in computed property name
+                // class A { foo() { return "1" }}
+                // class B {
+                //     [super.foo()]() {}
+                // }
+                let current = node;
+                while (current && current !== container && current.kind !== SyntaxKind.ComputedPropertyName) {
+                    current = current.parent;
+                }
+                if (current && current.kind === SyntaxKind.ComputedPropertyName) {
                     error(node, Diagnostics.super_cannot_be_referenced_in_a_computed_property_name);
                 }
                 else if (isCallExpression) {
                     error(node, Diagnostics.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors);
                 }
+                else if (!container || !container.parent || !(isClassLike(container.parent) || container.parent.kind === SyntaxKind.ObjectLiteralExpression)) {
+                    error(node, Diagnostics.super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions);
+                }
                 else {
                     error(node, Diagnostics.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class);
                 }
+                return unknownType;
+            }
 
+            if ((container.flags & NodeFlags.Static) || isCallExpression) {
+                nodeCheckFlag = NodeCheckFlags.SuperStatic;
+            }
+            else {
+                nodeCheckFlag = NodeCheckFlags.SuperInstance;
+            }
+
+            getNodeLinks(node).flags |= nodeCheckFlag;
+
+            if (needToCaptureLexicalThis) {
+                // call expressions are allowed only in constructors so they should always capture correct 'this'
+                // super property access expressions can also appear in arrow functions -
+                // in this case they should also use correct lexical this
+                captureLexicalThis(node.parent, container);
+            }
+
+            if (container.parent.kind === SyntaxKind.ObjectLiteralExpression) {
+                if (languageVersion < ScriptTarget.ES6) {
+                    error(node, Diagnostics.super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher);
+                    return unknownType;
+                }
+                else {
+                    // for object literal assume that type of 'super' is 'any'
+                    return anyType;
+                }
+            }
+
+            // at this point the only legal case for parent is ClassLikeDeclaration
+            const classLikeDeclaration = <ClassLikeDeclaration>container.parent;
+            const classType = <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(classLikeDeclaration));
+            const baseClassType = classType && getBaseTypes(classType)[0];
+            if (!baseClassType) {
+                if (!getClassExtendsHeritageClauseElement(classLikeDeclaration)) {
+                    error(node, Diagnostics.super_can_only_be_referenced_in_a_derived_class);
+                }
                 return unknownType;
             }
 
@@ -7142,8 +7186,8 @@ namespace ts {
                     // - In a constructor, instance member function, instance member accessor, or instance member variable initializer where this references a derived class instance
                     // - In a static member function or static member accessor
 
-                    // topmost container must be something that is directly nested in the class declaration
-                    if (container && isClassLike(container.parent)) {
+                    // topmost container must be something that is directly nested in the class declaration\object literal expression
+                    if (isClassLike(container.parent) || container.parent.kind === SyntaxKind.ObjectLiteralExpression) {
                         if (container.flags & NodeFlags.Static) {
                             return container.kind === SyntaxKind.MethodDeclaration ||
                                 container.kind === SyntaxKind.MethodSignature ||
@@ -7559,7 +7603,7 @@ namespace ts {
                         // This signature will contribute to contextual union signature
                         signatureList = [signature];
                     }
-                    else if (!compareSignatures(signatureList[0], signature, /*partialMatch*/ false, /*ignoreReturnTypes*/ true, compareTypes)) {
+                    else if (!compareSignaturesIdentical(signatureList[0], signature, /*partialMatch*/ false, /*ignoreReturnTypes*/ true, compareTypesIdentical)) {
                         // Signatures aren't identical, do not use
                         return undefined;
                     }
@@ -8035,7 +8079,6 @@ namespace ts {
         /// type or factory function.
         /// Otherwise, returns unknownSymbol.
         function getJsxElementTagSymbol(node: JsxOpeningLikeElement | JsxClosingElement): Symbol {
-            const flags: JsxFlags = JsxFlags.UnknownElement;
             const links = getNodeLinks(node);
             if (!links.resolvedSymbol) {
                 if (isJsxIntrinsicIdentifier(node.tagName)) {
@@ -8234,9 +8277,9 @@ namespace ts {
                             // Props is of type 'any' or unknown
                             return links.resolvedJsxType = attributesType;
                         }
-                        else if (!(attributesType.flags & TypeFlags.ObjectType)) {
-                            // Props is not an object type
-                            error(node.tagName, Diagnostics.JSX_element_attributes_type_0_must_be_an_object_type, typeToString(attributesType));
+                        else if (attributesType.flags & TypeFlags.Union) {
+                            // Props cannot be a union type
+                            error(node.tagName, Diagnostics.JSX_element_attributes_type_0_may_not_be_a_union_type, typeToString(attributesType));
                             return links.resolvedJsxType = anyType;
                         }
                         else {
@@ -11580,7 +11623,7 @@ namespace ts {
             }
 
             for (const otherSignature of signaturesToCheck) {
-                if (!otherSignature.hasStringLiterals && isSignatureAssignableTo(signature, otherSignature)) {
+                if (!otherSignature.hasStringLiterals && isSignatureAssignableTo(signature, otherSignature, /*ignoreReturnTypes*/ false)) {
                     return;
                 }
             }
@@ -11827,7 +11870,7 @@ namespace ts {
                         //
                         // The implementation is completely unrelated to the specialized signature, yet we do not check this.
                         for (const signature of signatures) {
-                            if (!signature.hasStringLiterals && !isSignatureAssignableTo(bodySignature, signature)) {
+                            if (!signature.hasStringLiterals && !isImplementationCompatibleWithOverload(bodySignature, signature)) {
                                 error(signature.declaration, Diagnostics.Overload_signature_is_not_compatible_with_function_implementation);
                                 break;
                             }
@@ -14308,16 +14351,6 @@ namespace ts {
             }
         }
 
-        function getModuleStatements(node: Declaration): Statement[] {
-            if (node.kind === SyntaxKind.SourceFile) {
-                return (<SourceFile>node).statements;
-            }
-            if (node.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>node).body.kind === SyntaxKind.ModuleBlock) {
-                return (<ModuleBlock>(<ModuleDeclaration>node).body).statements;
-            }
-            return emptyArray;
-        }
-
         function hasExportedMembers(moduleSymbol: Symbol) {
             for (var id in moduleSymbol.exports) {
                 if (id !== "export=") {
@@ -15396,20 +15429,6 @@ namespace ts {
             return symbol && getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration;
         }
 
-        function instantiateSingleCallFunctionType(functionType: Type, typeArguments: Type[]): Type {
-            if (functionType === unknownType) {
-                return unknownType;
-            }
-
-            const signature = getSingleCallSignature(functionType);
-            if (!signature) {
-                return unknownType;
-            }
-
-            const instantiatedSignature = getSignatureInstantiation(signature, typeArguments);
-            return getOrCreateTypeFromSignature(instantiatedSignature);
-        }
-
         function createResolver(): EmitResolver {
             return {
                 getReferencedExportContainer,
@@ -15544,7 +15563,12 @@ namespace ts {
                 return false;
             }
             if (!nodeCanBeDecorated(node)) {
-                return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_not_valid_here);
+                if (node.kind === SyntaxKind.MethodDeclaration && !ts.nodeIsPresent((<MethodDeclaration>node).body)) {
+                    return grammarErrorOnFirstToken(node, Diagnostics.A_decorator_can_only_decorate_a_method_implementation_not_an_overload);
+                }
+                else {
+                    return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_not_valid_here);
+                }
             }
             else if (node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor) {
                 const accessors = getAllAccessorDeclarations((<ClassDeclaration>node.parent).members, <AccessorDeclaration>node);
@@ -16458,25 +16482,6 @@ namespace ts {
             }
         }
 
-        function isIntegerLiteral(expression: Expression): boolean {
-            if (expression.kind === SyntaxKind.PrefixUnaryExpression) {
-                const unaryExpression = <PrefixUnaryExpression>expression;
-                if (unaryExpression.operator === SyntaxKind.PlusToken || unaryExpression.operator === SyntaxKind.MinusToken) {
-                    expression = unaryExpression.operand;
-                }
-            }
-            if (expression.kind === SyntaxKind.NumericLiteral) {
-                // Allows for scientific notation since literalExpression.text was formed by
-                // coercing a number to a string. Sometimes this coercion can yield a string
-                // in scientific notation.
-                // We also don't need special logic for hex because a hex integer is converted
-                // to decimal when it is coerced.
-                return /^[0-9]+([eE]\+?[0-9]+)?$/.test((<LiteralExpression>expression).text);
-            }
-
-            return false;
-        }
-
         function hasParseDiagnostics(sourceFile: SourceFile): boolean {
             return sourceFile.parseDiagnostics.length > 0;
         }
@@ -16505,11 +16510,6 @@ namespace ts {
             }
         }
 
-        function isEvalOrArgumentsIdentifier(node: Node): boolean {
-            return node.kind === SyntaxKind.Identifier &&
-                ((<Identifier>node).text === "eval" || (<Identifier>node).text === "arguments");
-        }
-
         function checkGrammarConstructorTypeParameters(node: ConstructorDeclaration) {
             if (node.typeParameters) {
                 return grammarErrorAtPos(getSourceFileOfNode(node), node.typeParameters.pos, node.typeParameters.end - node.typeParameters.pos, Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration);

src/compiler/core.ts

@@ -794,23 +794,6 @@ namespace ts {
         return path;
     }
 
-    const backslashOrDoubleQuote = /[\"\\]/g;
-    const escapedCharsRegExp = /[\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
-    const escapedCharsMap: Map<string> = {
-        "\0": "\\0",
-        "\t": "\\t",
-        "\v": "\\v",
-        "\f": "\\f",
-        "\b": "\\b",
-        "\r": "\\r",
-        "\n": "\\n",
-        "\\": "\\\\",
-        "\"": "\\\"",
-        "\u2028": "\\u2028", // lineSeparator
-        "\u2029": "\\u2029", // paragraphSeparator
-        "\u0085": "\\u0085"  // nextLine
-    };
-
     export interface ObjectAllocator {
         getNodeConstructor(): new (kind: SyntaxKind, pos?: number, end?: number) => Node;
         getSourceFileConstructor(): new (kind: SyntaxKind, pos?: number, end?: number) => SourceFile;

src/compiler/declarationEmitter.ts

@@ -1534,14 +1534,6 @@ namespace ts {
             }
 
             function emitBindingElement(bindingElement: BindingElement) {
-                function getBindingElementTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                    const diagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
-                    return diagnosticMessage !== undefined ? {
-                        diagnosticMessage,
-                        errorNode: bindingElement,
-                        typeName: bindingElement.name
-                    } : undefined;
-                }
 
                 if (bindingElement.kind === SyntaxKind.OmittedExpression) {
                     // If bindingElement is an omittedExpression (i.e. containing elision),

src/compiler/diagnosticMessages.json

@@ -795,6 +795,10 @@
         "category": "Error",
         "code": 1248
     },
+    "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
@@ -1691,7 +1695,7 @@
         "category": "Error",
         "code": 2528
     },
-    "JSX element attributes type '{0}' must be an object type.": {
+    "JSX element attributes type '{0}' may not be a union type.": {
         "category": "Error",
         "code": 2600
     },
@@ -1759,6 +1763,14 @@
         "category": "Error",
         "code": 2658
     },
+    "'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.": {
+        "category": "Error",
+        "code": 2659
+    },
+    "'super' can only be referenced in members of derived classes or object literal expressions.": {
+        "category": "Error",
+        "code": 2660
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000

src/compiler/emitter.ts

@@ -781,12 +781,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
             }
 
-            function emitTrailingCommaIfPresent(nodeList: NodeArray<Node>): void {
-                if (nodeList.hasTrailingComma) {
-                    write(",");
-                }
-            }
-
             function emitLinePreservingList(parent: Node, nodes: NodeArray<Node>, allowTrailingComma: boolean, spacesBetweenBraces: boolean) {
                 Debug.assert(nodes.length > 0);
 
@@ -2452,7 +2446,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitPrefixUnaryExpression(node: PrefixUnaryExpression) {
-                const exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(node.operand);
+                const exportChanged = (node.operator === SyntaxKind.PlusPlusToken || node.operator === SyntaxKind.MinusMinusToken) &&
+                    isNameOfExportedSourceLevelDeclarationInSystemExternalModule(node.operand);
 
                 if (exportChanged) {
                     // emit
@@ -3238,10 +3233,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
             }
 
-            function emitDownLevelForOfStatement(node: ForOfStatement) {
-                emitLoop(node, emitDownLevelForOfStatementWorker);
-            }
-
             function emitDownLevelForOfStatementWorker(node: ForOfStatement, loop: ConvertedLoop) {
                 // The following ES6 code:
                 //
@@ -4310,22 +4301,29 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                 // TODO (yuisu) : we should not have special cases to condition emitting comments
                 // but have one place to fix check for these conditions.
-                if (node.kind !== SyntaxKind.MethodDeclaration && node.kind !== SyntaxKind.MethodSignature &&
-                    node.parent && node.parent.kind !== SyntaxKind.PropertyAssignment &&
-                    node.parent.kind !== SyntaxKind.CallExpression) {
-                    // 1. Methods will emit the comments as part of emitting method declaration
-
+                const { kind, parent } = node;
+                if (kind !== SyntaxKind.MethodDeclaration &&
+                    kind !== SyntaxKind.MethodSignature &&
+                    parent &&
+                    parent.kind !== SyntaxKind.PropertyAssignment &&
+                    parent.kind !== SyntaxKind.CallExpression &&
+                    parent.kind !== SyntaxKind.ArrayLiteralExpression) {
+                    // 1. Methods will emit comments at their assignment declaration sites.
+                    //
                     // 2. If the function is a property of object literal, emitting leading-comments
-                    // is done by emitNodeWithoutSourceMap which then call this function.
-                    // In particular, we would like to avoid emit comments twice in following case:
-                    //      For example:
+                    //    is done by emitNodeWithoutSourceMap which then call this function.
+                    //    In particular, we would like to avoid emit comments twice in following case:
+                    //
                     //          var obj = {
                     //              id:
                     //                  /*comment*/ () => void
                     //          }
-
+                    //
                     // 3. If the function is an argument in call expression, emitting of comments will be
-                    // taken care of in emit list of arguments inside of emitCallexpression
+                    //    taken care of in emit list of arguments inside of 'emitCallExpression'.
+                    //
+                    // 4. If the function is in an array literal, 'emitLinePreservingList' will take care
+                    //    of leading comments.
                     emitLeadingComments(node);
                 }
 
@@ -4352,12 +4350,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 emitSignatureAndBody(node);
-                if (modulekind !== ModuleKind.ES6 && node.kind === SyntaxKind.FunctionDeclaration && node.parent === currentSourceFile && node.name) {
+                if (modulekind !== ModuleKind.ES6 && kind === SyntaxKind.FunctionDeclaration && parent === currentSourceFile && node.name) {
                     emitExportMemberAssignments((<FunctionDeclaration>node).name);
                 }
 
                 emitEnd(node);
-                if (node.kind !== SyntaxKind.MethodDeclaration && node.kind !== SyntaxKind.MethodSignature) {
+                if (kind !== SyntaxKind.MethodDeclaration && kind !== SyntaxKind.MethodSignature) {
                     emitTrailingComments(node);
                 }
             }

src/compiler/parser.ts

@@ -771,10 +771,6 @@ namespace ts {
             return doInsideOfContext(ParserContextFlags.Yield, func);
         }
 
-        function doOutsideOfYieldContext<T>(func: () => T): T {
-            return doOutsideOfContext(ParserContextFlags.Yield, func);
-        }
-
         function doInDecoratorContext<T>(func: () => T): T {
             return doInsideOfContext(ParserContextFlags.Decorator, func);
         }
@@ -791,10 +787,6 @@ namespace ts {
             return doInsideOfContext(ParserContextFlags.Yield | ParserContextFlags.Await, func);
         }
 
-        function doOutsideOfYieldAndAwaitContext<T>(func: () => T): T {
-            return doOutsideOfContext(ParserContextFlags.Yield | ParserContextFlags.Await, func);
-        }
-
         function inContext(flags: ParserContextFlags) {
             return (contextFlags & flags) !== 0;
         }
@@ -851,10 +843,6 @@ namespace ts {
             return token = scanner.scan();
         }
 
-        function getTokenPos(pos: number): number {
-            return skipTrivia(sourceText, pos);
-        }
-
         function reScanGreaterToken(): SyntaxKind {
             return token = scanner.reScanGreaterToken();
         }
@@ -2644,10 +2632,6 @@ namespace ts {
                 isStartOfExpression();
         }
 
-        function allowInAndParseExpression(): Expression {
-            return allowInAnd(parseExpression);
-        }
-
         function parseExpression(): Expression {
             // Expression[in]:
             //      AssignmentExpression[in]
@@ -3962,7 +3946,6 @@ namespace ts {
 
             const asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken);
             const tokenIsIdentifier = isIdentifier();
-            const nameToken = token;
             const propertyName = parsePropertyName();
 
             // Disallowing of optional property assignments happens in the grammar checker.
@@ -5104,10 +5087,6 @@ namespace ts {
             return undefined;
         }
 
-        function parseHeritageClausesWorker() {
-            return parseList(ParsingContext.HeritageClauses, parseHeritageClause);
-        }
-
         function parseHeritageClause() {
             if (token === SyntaxKind.ExtendsKeyword || token === SyntaxKind.ImplementsKeyword) {
                 const node = <HeritageClause>createNode(SyntaxKind.HeritageClause);
@@ -5253,12 +5232,6 @@ namespace ts {
             return nextToken() === SyntaxKind.SlashToken;
         }
 
-        function nextTokenIsCommaOrFromKeyword() {
-            nextToken();
-            return token === SyntaxKind.CommaToken ||
-                token === SyntaxKind.FromKeyword;
-        }
-
         function parseImportDeclarationOrImportEqualsDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): ImportEqualsDeclaration | ImportDeclaration {
             parseExpected(SyntaxKind.ImportKeyword);
             const afterImportPos = scanner.getStartPos();
@@ -5751,13 +5724,6 @@ namespace ts {
                 return finishNode(parameter);
             }
 
-            function parseJSDocOptionalType(type: JSDocType): JSDocOptionalType {
-                const result = <JSDocOptionalType>createNode(SyntaxKind.JSDocOptionalType, type.pos);
-                nextToken();
-                result.type = type;
-                return finishNode(result);
-            }
-
             function parseJSDocTypeReference(): JSDocTypeReference {
                 const result = <JSDocTypeReference>createNode(SyntaxKind.JSDocTypeReference);
                 result.name = parseSimplePropertyName();

src/compiler/program.ts

@@ -573,8 +573,11 @@ namespace ts {
             // If the noEmitOnError flag is set, then check if we have any errors so far.  If so,
             // immediately bail out.  Note that we pass 'undefined' for 'sourceFile' so that we
             // get any preEmit diagnostics, not just the ones
-            if (options.noEmitOnError && getPreEmitDiagnostics(program, /*sourceFile:*/ undefined, cancellationToken).length > 0) {
-                return { diagnostics: [], sourceMaps: undefined, emitSkipped: true };
+            if (options.noEmitOnError) {
+                const preEmitDiagnostics = getPreEmitDiagnostics(program, /*sourceFile:*/ undefined, cancellationToken);
+                if (preEmitDiagnostics.length > 0) {
+                    return { diagnostics: preEmitDiagnostics, sourceMaps: undefined, emitSkipped: true };
+                }
             }
 
             // Create the emit resolver outside of the "emitTime" tracking code below.  That way

src/compiler/sourcemap.ts

@@ -15,7 +15,6 @@ namespace ts {
         reset(): void;
     }
 
-    const nop = <(...args: any[]) => any>Function.prototype;
     let nullSourceMapWriter: SourceMapWriter;
 
     export function getNullSourceMapWriter(): SourceMapWriter {

src/compiler/sys.ts

@@ -218,7 +218,6 @@ namespace ts {
             const _fs = require("fs");
             const _path = require("path");
             const _os = require("os");
-            const _tty = require("tty");
 
             // average async stat takes about 30 microseconds
             // set chunk size to do 30 files in < 1 millisecond
@@ -313,10 +312,6 @@ namespace ts {
             // time dynamically to match the large reference set?
             const watchedFileSet = createWatchedFileSet();
 
-            function isNode4OrLater(): Boolean {
-                return parseInt(process.version.charAt(1)) >= 4;
-            }
-
             const platform: string = _os.platform();
             // win32\win64 are case insensitive platforms, MacOS (darwin) by default is also case insensitive
             const useCaseSensitiveFileNames = platform !== "win32" && platform !== "win64" && platform !== "darwin";

src/compiler/types.ts

@@ -1195,7 +1195,7 @@ namespace ts {
 
     // @kind(SyntaxKind.CaseClause)
     export interface CaseClause extends Node {
-        expression?: Expression;
+        expression: Expression;
         statements: NodeArray<Statement>;
     }
 
@@ -1723,6 +1723,7 @@ namespace ts {
 
         getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
         getSymbolAtLocation(node: Node): Symbol;
+        getSymbolsOfParameterPropertyDeclaration(parameter: ParameterDeclaration, parameterName: string): Symbol[];
         getShorthandAssignmentValueSymbol(location: Node): Symbol;
         getTypeAtLocation(node: Node): Type;
         typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;

src/compiler/utilities.ts

@@ -775,26 +775,38 @@ namespace ts {
         }
     }
 
-    export function getSuperContainer(node: Node, includeFunctions: boolean): Node {
+    /**
+      * 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. 
+      *   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 if he needs to climb higher)
+      * - super call\property is definitely illegal in the node (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 {
         while (true) {
             node = node.parent;
-            if (!node) return node;
+            if (!node) {
+                return node;
+            }
             switch (node.kind) {
                 case SyntaxKind.ComputedPropertyName:
-                    // If the grandparent node is an object literal (as opposed to a class),
-                    // then the computed property is not a 'super' container.
-                    // A computed property name in a class needs to be a super container
-                    // so that we can error on it.
-                    if (isClassLike(node.parent.parent)) {
-                        return node;
-                    }
-                    // If this is a computed property, then the parent should not
-                    // make it a super container. The parent might be a property
-                    // in an object literal, like a method or accessor. But in order for
-                    // such a parent to be a super container, the reference must be in
-                    // the *body* of the container.
                     node = node.parent;
                     break;
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.FunctionExpression:
+                case SyntaxKind.ArrowFunction:
+                    if (!stopOnFunctions) {
+                        continue;
+                    }
+                case SyntaxKind.PropertyDeclaration:
+                case SyntaxKind.PropertySignature:
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.MethodSignature:
+                case SyntaxKind.Constructor:
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                    return node;
                 case SyntaxKind.Decorator:
                     // Decorators are always applied outside of the body of a class or method.
                     if (node.parent.kind === SyntaxKind.Parameter && isClassElement(node.parent.parent)) {
@@ -808,20 +820,6 @@ namespace ts {
                         node = node.parent;
                     }
                     break;
-                case SyntaxKind.FunctionDeclaration:
-                case SyntaxKind.FunctionExpression:
-                case SyntaxKind.ArrowFunction:
-                    if (!includeFunctions) {
-                        continue;
-                    }
-                case SyntaxKind.PropertyDeclaration:
-                case SyntaxKind.PropertySignature:
-                case SyntaxKind.MethodDeclaration:
-                case SyntaxKind.MethodSignature:
-                case SyntaxKind.Constructor:
-                case SyntaxKind.GetAccessor:
-                case SyntaxKind.SetAccessor:
-                    return node;
             }
         }
     }
@@ -2748,4 +2746,8 @@ namespace ts {
             }
         }
     }
+
+    export function isParameterPropertyDeclaration(node: ParameterDeclaration): boolean {
+        return node.flags & NodeFlags.AccessibilityModifier && node.parent.kind === SyntaxKind.Constructor && isClassLike(node.parent.parent);
+    }
 }

src/harness/compilerRunner.ts

@@ -251,7 +251,6 @@ class CompilerBaselineRunner extends RunnerBase {
                     const allFiles = toBeCompiled.concat(otherFiles).filter(file => !!program.getSourceFile(file.unitName));
 
                     const fullWalker = new TypeWriterWalker(program, /*fullTypeCheck*/ true);
-                    const pullWalker = new TypeWriterWalker(program, /*fullTypeCheck*/ false);
 
                     const fullResults: ts.Map<TypeWriterResult[]> = {};
                     const pullResults: ts.Map<TypeWriterResult[]> = {};

src/harness/fourslash.ts

@@ -321,11 +321,6 @@ namespace FourSlash {
                 PlaceOpenBraceOnNewLineForControlBlocks: false,
             };
 
-            this.testData.files.forEach(file => {
-                const fileName = file.fileName.replace(Harness.IO.directoryName(file.fileName), "").substr(1);
-                const fileNameWithoutExtension = fileName.substr(0, fileName.lastIndexOf("."));
-            });
-
             // Open the first file by default
             this.openFile(0);
         }
@@ -762,10 +757,6 @@ namespace FourSlash {
             return this.languageService.getReferencesAtPosition(this.activeFile.fileName, this.currentCaretPosition);
         }
 
-        private assertionMessage(name: string, actualValue: any, expectedValue: any) {
-            return "\nActual " + name + ":\n\t" + actualValue + "\nExpected value:\n\t" + expectedValue;
-        }
-
         public getSyntacticDiagnostics(expected: string) {
             const diagnostics = this.languageService.getSyntacticDiagnostics(this.activeFile.fileName);
             this.testDiagnostics(expected, diagnostics);
@@ -910,7 +901,6 @@ namespace FourSlash {
         }
 
         public verifyCurrentParameterSpanIs(parameter: string) {
-            const activeSignature = this.getActiveSignatureHelpItem();
             const activeParameter = this.getActiveParameter();
             assert.equal(ts.displayPartsToString(activeParameter.displayParts), parameter);
         }
@@ -2195,9 +2185,6 @@ namespace FourSlash {
         }
     }
 
-    // TOOD: should these just use the Harness's stdout/stderr?
-    const fsOutput = new Harness.Compiler.WriterAggregator();
-    const fsErrors = new Harness.Compiler.WriterAggregator();
     export function runFourSlashTest(basePath: string, testType: FourSlashTestType, fileName: string) {
         const content = Harness.IO.readFile(fileName);
         runFourSlashTestContent(basePath, testType, content, fileName);
@@ -2788,6 +2775,10 @@ namespace FourSlashInterface {
             this.state.verifyCompletionListItemsCountIsGreaterThan(count, this.negative);
         }
 
+        public assertHasRanges(ranges: FourSlash.Range[]) {
+            assert(ranges.length !== 0, "Array of ranges is expected to be non-empty");
+        }
+
         public completionListIsEmpty() {
             this.state.verifyCompletionListIsEmpty(this.negative);
         }

src/harness/harness.ts

@@ -31,7 +31,6 @@
 // this will work in the browser via browserify
 var _chai: typeof chai = require("chai");
 var assert: typeof _chai.assert = _chai.assert;
-var expect: typeof _chai.expect = _chai.expect;
 declare var __dirname: string; // Node-specific
 var global = <any>Function("return this").call(null);
 /* tslint:enable:no-var-keyword */
@@ -513,7 +512,6 @@ namespace Harness {
                 }
 
                 const folder: any = fso.GetFolder(path);
-                const paths: string[] = [];
 
                 return filesInFolder(folder, path);
             };
@@ -617,7 +615,6 @@ namespace Harness {
             export const getExecutingFilePath = () => "";
             export const exit = (exitCode: number) => {};
 
-            const supportsCodePage = () => false;
             export let log = (s: string) => console.log(s);
 
             namespace Http {
@@ -627,18 +624,6 @@ namespace Harness {
                 }
 
                 /// Ask the server to use node's path.resolve to resolve the given path
-                function getResolvedPathFromServer(path: string) {
-                    const xhr = new XMLHttpRequest();
-                    try {
-                        xhr.open("GET", path + "?resolve", /*async*/ false);
-                        xhr.send();
-                    }
-                    catch (e) {
-                        return { status: 404, responseText: null };
-                    }
-
-                    return waitForXHR(xhr);
-                }
 
                 export interface XHRResponse {
                     status: number;

src/harness/harnessLanguageService.ts

@@ -315,13 +315,6 @@ namespace Harness.LanguageService {
     class LanguageServiceShimProxy implements ts.LanguageService {
         constructor(private shim: ts.LanguageServiceShim) {
         }
-        private unwrappJSONCallResult(result: string): any {
-            const parsedResult = JSON.parse(result);
-            if (parsedResult.error) {
-                throw new Error("Language Service Shim Error: " + JSON.stringify(parsedResult.error));
-            }
-            return parsedResult.result;
-        }
         cleanupSemanticCache(): void {
             this.shim.cleanupSemanticCache();
         }

src/harness/loggedIO.ts

@@ -305,25 +305,6 @@ namespace Playback {
         }
     }
 
-    const pathEquivCache: any = {};
-    function pathsAreEquivalent(left: string, right: string, wrapper: { resolvePath(s: string): string }) {
-        const key = left + "-~~-" + right;
-        function areSame(a: string, b: string) {
-            return ts.normalizeSlashes(a).toLowerCase() === ts.normalizeSlashes(b).toLowerCase();
-        }
-        function check() {
-            if (Harness.Path.getFileName(left).toLowerCase() === Harness.Path.getFileName(right).toLowerCase()) {
-                return areSame(left, right) || areSame(wrapper.resolvePath(left), right) || areSame(left, wrapper.resolvePath(right)) || areSame(wrapper.resolvePath(left), wrapper.resolvePath(right));
-            }
-        }
-        if (pathEquivCache.hasOwnProperty(key)) {
-            return pathEquivCache[key];
-        }
-        else {
-            return pathEquivCache[key] = check();
-        }
-    }
-
     function noOpReplay(name: string) {
         // console.log("Swallowed write operation during replay: " + name);
     }

src/server/editorServices.ts

@@ -263,13 +263,11 @@ namespace ts.server {
         }
 
         resolvePath(path: string): string {
-            const start = new Date().getTime();
             const result = this.host.resolvePath(path);
             return result;
         }
 
         fileExists(path: string): boolean {
-            const start = new Date().getTime();
             const result = this.host.fileExists(path);
             return result;
         }
@@ -325,32 +323,6 @@ namespace ts.server {
         }
     }
 
-    // assumes normalized paths
-    function getAbsolutePath(filename: string, directory: string) {
-        const rootLength = ts.getRootLength(filename);
-        if (rootLength > 0) {
-            return filename;
-        }
-        else {
-            const splitFilename = filename.split("/");
-            const splitDir = directory.split("/");
-            let i = 0;
-            let dirTail = 0;
-            const sflen = splitFilename.length;
-            while ((i < sflen) && (splitFilename[i].charAt(0) == ".")) {
-                const dots = splitFilename[i];
-                if (dots == "..") {
-                    dirTail++;
-                }
-                else if (dots != ".") {
-                    return undefined;
-                }
-                i++;
-            }
-            return splitDir.slice(0, splitDir.length - dirTail).concat(splitFilename.slice(i)).join("/");
-        }
-    }
-
     export interface ProjectOptions {
         // these fields can be present in the project file
         files?: string[];
@@ -514,7 +486,7 @@ namespace ts.server {
         // number becomes 0 for a watcher, then we should close it.
         directoryWatchersRefCount: ts.Map<number> = {};
         hostConfiguration: HostConfiguration;
-        timerForDetectingProjectFilelistChanges: Map<NodeJS.Timer> = {};
+        timerForDetectingProjectFileListChanges: Map<NodeJS.Timer> = {};
 
         constructor(public host: ServerHost, public psLogger: Logger, public eventHandler?: ProjectServiceEventHandler) {
             // ts.disableIncrementalParsing = true;
@@ -569,21 +541,22 @@ namespace ts.server {
             }
 
             this.log("Detected source file changes: " + fileName);
-            this.startTimerForDetectingProjectFilelistChanges(project);
+            this.startTimerForDetectingProjectFileListChanges(project);
         }
 
-        startTimerForDetectingProjectFilelistChanges(project: Project) {
-            if (this.timerForDetectingProjectFilelistChanges[project.projectFilename]) {
-                clearTimeout(this.timerForDetectingProjectFilelistChanges[project.projectFilename]);
+        startTimerForDetectingProjectFileListChanges(project: Project) {
+            if (this.timerForDetectingProjectFileListChanges[project.projectFilename]) {
+                clearTimeout(this.timerForDetectingProjectFileListChanges[project.projectFilename]);
             }
-            this.timerForDetectingProjectFilelistChanges[project.projectFilename] = setTimeout(
-                () => this.handleProjectFilelistChanges(project),
+            this.timerForDetectingProjectFileListChanges[project.projectFilename] = setTimeout(
+                () => this.handleProjectFileListChanges(project),
                 250
             );
         }
 
-        handleProjectFilelistChanges(project: Project) {
-            const { succeeded, projectOptions, error } = this.configFileToProjectOptions(project.projectFilename);
+        handleProjectFileListChanges(project: Project) {
+            const { projectOptions } = this.configFileToProjectOptions(project.projectFilename);
+
             const newRootFiles = projectOptions.files.map((f => this.getCanonicalFileName(f)));
             const currentRootFiles = project.getRootFiles().map((f => this.getCanonicalFileName(f)));
 
@@ -611,7 +584,8 @@ namespace ts.server {
 
             this.log("Detected newly added tsconfig file: " + fileName);
 
-            const { succeeded, projectOptions, error } = this.configFileToProjectOptions(fileName);
+            const { projectOptions } = this.configFileToProjectOptions(fileName);
+
             const rootFilesInTsconfig = projectOptions.files.map(f => this.getCanonicalFileName(f));
             const openFileRoots = this.openFileRoots.map(s => this.getCanonicalFileName(s.fileName));
 
@@ -1109,7 +1083,6 @@ namespace ts.server {
          * Close file whose contents is managed by the client
          * @param filename is absolute pathname
          */
-
         closeClientFile(filename: string) {
             const info = ts.lookUp(this.filenameToScriptInfo, filename);
             if (info) {
@@ -1765,9 +1738,9 @@ namespace ts.server {
         }
 
         getLineMapper() {
-            return ((line: number) => {
+            return (line: number) => {
                 return this.index.lineNumberToInfo(line).offset;
-            });
+            };
         }
 
         getTextChangeRangeSinceVersion(scriptVersion: number) {

src/server/server.ts

@@ -4,9 +4,7 @@
 /* tslint:disable:no-null */
 
 namespace ts.server {
-    const nodeproto: typeof NodeJS._debugger = require("_debugger");
     const readline: NodeJS.ReadLine = require("readline");
-    const path: NodeJS.Path = require("path");
     const fs: typeof NodeJS.fs = require("fs");
 
     const rl = readline.createInterface({

src/server/session.ts

@@ -129,9 +129,6 @@ namespace ts.server {
 
     export class Session {
         protected projectService: ProjectService;
-        private pendingOperation = false;
-        private fileHash: ts.Map<number> = {};
-        private nextFileId = 1;
         private errorTimer: any; /*NodeJS.Timer | number*/
         private immediateId: any;
         private changeSeq = 0;
@@ -239,11 +236,6 @@ namespace ts.server {
             }
         }
 
-        private errorCheck(file: string, project: Project) {
-            this.syntacticCheck(file, project);
-            this.semanticCheck(file, project);
-        }
-
         private reloadProjects() {
             this.projectService.reloadProjects();
         }
@@ -901,7 +893,7 @@ namespace ts.server {
         }
 
         getDiagnosticsForProject(delay: number, fileName: string) {
-            const { configFileName, fileNames } = this.getProjectInfo(fileName, /*needFileNameList*/ true);
+            const { fileNames } = this.getProjectInfo(fileName, /*needFileNameList*/ true);
             // No need to analyze lib.d.ts
             let fileNamesInProject = fileNames.filter((value, index, array) => value.indexOf("lib.d.ts") < 0);
 

tests/baselines/reference/DeclarationErrorsNoEmitOnError.errors.txt

@@ -0,0 +1,11 @@
+tests/cases/compiler/DeclarationErrorsNoEmitOnError.ts(4,8): error TS4033: Property 'f' of exported interface has or is using private name 'T'.
+
+
+==== tests/cases/compiler/DeclarationErrorsNoEmitOnError.ts (1 errors) ====
+    
+    type T = { x : number }
+    export interface I {
+        f: T;   
+           ~
+!!! error TS4033: Property 'f' of exported interface has or is using private name 'T'.
+    }

tests/baselines/reference/arrayLiteralComments.js

@@ -0,0 +1,31 @@
+//// [arrayLiteralComments.ts]
+var testArrayWithFunc = [
+    // Function comment
+    function() {
+        let x = 1;
+    },
+    // String comment
+    '1',
+    // Numeric comment
+    2,
+    // Object comment
+    { a: 1 },
+    // Array comment
+    [1, 2, 3]
+]
+
+//// [arrayLiteralComments.js]
+var testArrayWithFunc = [
+    // Function comment
+    function () {
+        var x = 1;
+    },
+    // String comment
+    '1',
+    // Numeric comment
+    2,
+    // Object comment
+    { a: 1 },
+    // Array comment
+    [1, 2, 3]
+];

tests/baselines/reference/arrayLiteralComments.symbols

@@ -0,0 +1,21 @@
+=== tests/cases/compiler/arrayLiteralComments.ts ===
+var testArrayWithFunc = [
+>testArrayWithFunc : Symbol(testArrayWithFunc, Decl(arrayLiteralComments.ts, 0, 3))
+
+    // Function comment
+    function() {
+        let x = 1;
+>x : Symbol(x, Decl(arrayLiteralComments.ts, 3, 11))
+
+    },
+    // String comment
+    '1',
+    // Numeric comment
+    2,
+    // Object comment
+    { a: 1 },
+>a : Symbol(a, Decl(arrayLiteralComments.ts, 10, 5))
+
+    // Array comment
+    [1, 2, 3]
+]

tests/baselines/reference/arrayLiteralComments.types

@@ -0,0 +1,36 @@
+=== tests/cases/compiler/arrayLiteralComments.ts ===
+var testArrayWithFunc = [
+>testArrayWithFunc : ((() => void) | string | number | { a: number; } | number[])[]
+>[    // Function comment    function() {        let x = 1;    },    // String comment    '1',    // Numeric comment    2,    // Object comment    { a: 1 },    // Array comment    [1, 2, 3]] : ((() => void) | string | number | { a: number; } | number[])[]
+
+    // Function comment
+    function() {
+>function() {        let x = 1;    } : () => void
+
+        let x = 1;
+>x : number
+>1 : number
+
+    },
+    // String comment
+    '1',
+>'1' : string
+
+    // Numeric comment
+    2,
+>2 : number
+
+    // Object comment
+    { a: 1 },
+>{ a: 1 } : { a: number; }
+>a : number
+>1 : number
+
+    // Array comment
+    [1, 2, 3]
+>[1, 2, 3] : number[]
+>1 : number
+>2 : number
+>3 : number
+
+]

tests/baselines/reference/computedPropertyNames30_ES5.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES5.ts(11,19): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
+tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES5.ts(11,19): error TS2466: 'super' cannot be referenced in a computed property name.
 
 
 ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES5.ts (1 errors) ====
@@ -14,7 +14,7 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES5.ts(11
                     //treatment of other similar violations.
                     [(super(), "prop")]() { }
                       ~~~~~
-!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
+!!! error TS2466: 'super' cannot be referenced in a computed property name.
                 };
             }
         }

tests/baselines/reference/computedPropertyNames30_ES6.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES6.ts(11,19): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
+tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES6.ts(11,19): error TS2466: 'super' cannot be referenced in a computed property name.
 
 
 ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES6.ts (1 errors) ====
@@ -14,7 +14,7 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames30_ES6.ts(11
                     //treatment of other similar violations.
                     [(super(), "prop")]() { }
                       ~~~~~
-!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
+!!! error TS2466: 'super' cannot be referenced in a computed property name.
                 };
             }
         }

tests/baselines/reference/conformanceFunctionOverloads.js

@@ -1,37 +0,0 @@
-//// [conformanceFunctionOverloads.ts]
-// Function overloads do not emit code
-
-// Function overload signature with optional parameter
-
-// Function overload signature with optional parameter
-
-// Function overloads with generic and non-generic overloads
-
-// Function overloads whose only difference is returning different unconstrained generic parameters
-
-// Function overloads whose only difference is returning different constrained generic parameters
-
-// Function overloads that differ only by type parameter constraints
-
-// Function overloads with matching accessibility
-
-// Function overloads with matching export
-
-// Function overloads with more params than implementation signature
-
-// Function overloads where return types are same infinitely recursive type reference
-
-
-
-//// [conformanceFunctionOverloads.js]
-// Function overloads do not emit code
-// Function overload signature with optional parameter
-// Function overload signature with optional parameter
-// Function overloads with generic and non-generic overloads
-// Function overloads whose only difference is returning different unconstrained generic parameters
-// Function overloads whose only difference is returning different constrained generic parameters
-// Function overloads that differ only by type parameter constraints
-// Function overloads with matching accessibility
-// Function overloads with matching export
-// Function overloads with more params than implementation signature
-// Function overloads where return types are same infinitely recursive type reference

tests/baselines/reference/conformanceFunctionOverloads.symbols

@@ -1,25 +0,0 @@
-=== tests/cases/conformance/functions/conformanceFunctionOverloads.ts ===
-// Function overloads do not emit code
-No type information for this code.
-No type information for this code.// Function overload signature with optional parameter
-No type information for this code.
-No type information for this code.// Function overload signature with optional parameter
-No type information for this code.
-No type information for this code.// Function overloads with generic and non-generic overloads
-No type information for this code.
-No type information for this code.// Function overloads whose only difference is returning different unconstrained generic parameters
-No type information for this code.
-No type information for this code.// Function overloads whose only difference is returning different constrained generic parameters
-No type information for this code.
-No type information for this code.// Function overloads that differ only by type parameter constraints
-No type information for this code.
-No type information for this code.// Function overloads with matching accessibility
-No type information for this code.
-No type information for this code.// Function overloads with matching export
-No type information for this code.
-No type information for this code.// Function overloads with more params than implementation signature
-No type information for this code.
-No type information for this code.// Function overloads where return types are same infinitely recursive type reference
-No type information for this code.
-No type information for this code.
-No type information for this code.

tests/baselines/reference/conformanceFunctionOverloads.types

@@ -1,25 +0,0 @@
-=== tests/cases/conformance/functions/conformanceFunctionOverloads.ts ===
-// Function overloads do not emit code
-No type information for this code.
-No type information for this code.// Function overload signature with optional parameter
-No type information for this code.
-No type information for this code.// Function overload signature with optional parameter
-No type information for this code.
-No type information for this code.// Function overloads with generic and non-generic overloads
-No type information for this code.
-No type information for this code.// Function overloads whose only difference is returning different unconstrained generic parameters
-No type information for this code.
-No type information for this code.// Function overloads whose only difference is returning different constrained generic parameters
-No type information for this code.
-No type information for this code.// Function overloads that differ only by type parameter constraints
-No type information for this code.
-No type information for this code.// Function overloads with matching accessibility
-No type information for this code.
-No type information for this code.// Function overloads with matching export
-No type information for this code.
-No type information for this code.// Function overloads with more params than implementation signature
-No type information for this code.
-No type information for this code.// Function overloads where return types are same infinitely recursive type reference
-No type information for this code.
-No type information for this code.
-No type information for this code.

tests/baselines/reference/decoratorOnClassMethod12.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/conformance/decorators/class/method/decoratorOnClassMethod12.ts(6,10): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+tests/cases/conformance/decorators/class/method/decoratorOnClassMethod12.ts(6,10): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
 
 
 ==== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod12.ts (1 errors) ====
@@ -9,7 +9,7 @@ tests/cases/conformance/decorators/class/method/decoratorOnClassMethod12.ts(6,10
         class C extends S {
             @super.decorator
              ~~~~~
-!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
             method() { }
         }
     }

tests/baselines/reference/decoratorOnClassMethodOverload1.errors.txt

@@ -0,0 +1,13 @@
+tests/cases/conformance/decorators/class/method/decoratorOnClassMethodOverload1.ts(4,5): error TS1249: A decorator can only decorate a method implementation, not an overload.
+
+
+==== tests/cases/conformance/decorators/class/method/decoratorOnClassMethodOverload1.ts (1 errors) ====
+    declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T>;
+    
+    class C {
+        @dec
+        ~
+!!! error TS1249: A decorator can only decorate a method implementation, not an overload.
+        method()
+        method() { }
+    }

tests/baselines/reference/decoratorOnClassMethodOverload1.js

@@ -0,0 +1,16 @@
+//// [decoratorOnClassMethodOverload1.ts]
+declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T>;
+
+class C {
+    @dec
+    method()
+    method() { }
+}
+
+//// [decoratorOnClassMethodOverload1.js]
+var C = (function () {
+    function C() {
+    }
+    C.prototype.method = function () { };
+    return C;
+}());

tests/baselines/reference/decoratorOnClassMethodOverload2.js

@@ -0,0 +1,25 @@
+//// [decoratorOnClassMethodOverload2.ts]
+declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T>;
+
+class C {
+    method()
+    @dec
+    method() { }
+}
+
+//// [decoratorOnClassMethodOverload2.js]
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var C = (function () {
+    function C() {
+    }
+    C.prototype.method = function () { };
+    __decorate([
+        dec
+    ], C.prototype, "method", null);
+    return C;
+}());

tests/baselines/reference/decoratorOnClassMethodOverload2.symbols

@@ -0,0 +1,24 @@
+=== tests/cases/conformance/decorators/class/method/decoratorOnClassMethodOverload2.ts ===
+declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T>;
+>dec : Symbol(dec, Decl(decoratorOnClassMethodOverload2.ts, 0, 0))
+>T : Symbol(T, Decl(decoratorOnClassMethodOverload2.ts, 0, 21))
+>target : Symbol(target, Decl(decoratorOnClassMethodOverload2.ts, 0, 24))
+>propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethodOverload2.ts, 0, 36))
+>descriptor : Symbol(descriptor, Decl(decoratorOnClassMethodOverload2.ts, 0, 57))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
+>T : Symbol(T, Decl(decoratorOnClassMethodOverload2.ts, 0, 21))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
+>T : Symbol(T, Decl(decoratorOnClassMethodOverload2.ts, 0, 21))
+
+class C {
+>C : Symbol(C, Decl(decoratorOnClassMethodOverload2.ts, 0, 126))
+
+    method()
+>method : Symbol(method, Decl(decoratorOnClassMethodOverload2.ts, 2, 9), Decl(decoratorOnClassMethodOverload2.ts, 3, 12))
+
+    @dec
+>dec : Symbol(dec, Decl(decoratorOnClassMethodOverload2.ts, 0, 0))
+
+    method() { }
+>method : Symbol(method, Decl(decoratorOnClassMethodOverload2.ts, 2, 9), Decl(decoratorOnClassMethodOverload2.ts, 3, 12))
+}

tests/baselines/reference/decoratorOnClassMethodOverload2.types

@@ -0,0 +1,24 @@
+=== tests/cases/conformance/decorators/class/method/decoratorOnClassMethodOverload2.ts ===
+declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T>;
+>dec : <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>
+>T : T
+>target : any
+>propertyKey : string
+>descriptor : TypedPropertyDescriptor<T>
+>TypedPropertyDescriptor : TypedPropertyDescriptor<T>
+>T : T
+>TypedPropertyDescriptor : TypedPropertyDescriptor<T>
+>T : T
+
+class C {
+>C : C
+
+    method()
+>method : () => any
+
+    @dec
+>dec : <T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>
+
+    method() { }
+>method : () => any
+}

tests/baselines/reference/emitThisInSuperMethodCall.errors.txt

@@ -1,6 +1,6 @@
-tests/cases/compiler/emitThisInSuperMethodCall.ts(10,17): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
-tests/cases/compiler/emitThisInSuperMethodCall.ts(17,17): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
-tests/cases/compiler/emitThisInSuperMethodCall.ts(23,13): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+tests/cases/compiler/emitThisInSuperMethodCall.ts(10,17): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/compiler/emitThisInSuperMethodCall.ts(17,17): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/compiler/emitThisInSuperMethodCall.ts(23,13): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
 
 
 ==== tests/cases/compiler/emitThisInSuperMethodCall.ts (3 errors) ====
@@ -15,7 +15,7 @@ tests/cases/compiler/emitThisInSuperMethodCall.ts(23,13): error TS2338: 'super'
                 function inner() {
                     super.sayHello();
                     ~~~~~
-!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
                 }
             };
         }
@@ -24,7 +24,7 @@ tests/cases/compiler/emitThisInSuperMethodCall.ts(23,13): error TS2338: 'super'
                 () => {
                     super.sayHello();
                     ~~~~~
-!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
                 }
             }
         }
@@ -32,7 +32,7 @@ tests/cases/compiler/emitThisInSuperMethodCall.ts(23,13): error TS2338: 'super'
             function inner() {
                 super.sayHello();
                 ~~~~~
-!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
             }
         }
     }

tests/baselines/reference/enumAssignmentCompat3.errors.txt

@@ -0,0 +1,129 @@
+tests/cases/compiler/enumAssignmentCompat3.ts(68,1): error TS2322: Type 'Abcd.E' is not assignable to type 'First.E'.
+  Property 'd' is missing in type 'First.E'.
+tests/cases/compiler/enumAssignmentCompat3.ts(70,1): error TS2322: Type 'Cd.E' is not assignable to type 'First.E'.
+  Property 'd' is missing in type 'First.E'.
+tests/cases/compiler/enumAssignmentCompat3.ts(71,1): error TS2322: Type 'Nope' is not assignable to type 'E'.
+tests/cases/compiler/enumAssignmentCompat3.ts(75,1): error TS2322: Type 'First.E' is not assignable to type 'Ab.E'.
+  Property 'c' is missing in type 'Ab.E'.
+tests/cases/compiler/enumAssignmentCompat3.ts(76,1): error TS2322: Type 'First.E' is not assignable to type 'Cd.E'.
+  Property 'a' is missing in type 'Cd.E'.
+tests/cases/compiler/enumAssignmentCompat3.ts(77,1): error TS2322: Type 'E' is not assignable to type 'Nope'.
+tests/cases/compiler/enumAssignmentCompat3.ts(82,1): error TS2322: Type 'Const.E' is not assignable to type 'First.E'.
+tests/cases/compiler/enumAssignmentCompat3.ts(83,1): error TS2322: Type 'First.E' is not assignable to type 'Const.E'.
+tests/cases/compiler/enumAssignmentCompat3.ts(86,1): error TS2322: Type 'Merged.E' is not assignable to type 'First.E'.
+  Property 'd' is missing in type 'First.E'.
+
+
+==== tests/cases/compiler/enumAssignmentCompat3.ts (9 errors) ====
+    namespace First {
+        export enum E {
+            a, b, c,
+        }
+    }
+    namespace Abc {
+        export enum E {
+            a, b, c,
+        }
+        export enum Nope {
+            a, b, c,
+        }
+    }
+    namespace Abcd {
+        export enum E {
+            a, b, c, d,
+        }
+    }
+    namespace Ab {
+        export enum E {
+            a, b,
+        }
+    }
+    namespace Cd {
+        export enum E {
+            c, d,
+        }
+    }
+    namespace Const {
+        export const enum E {
+            a, b, c,
+        }
+    }
+    namespace Decl {
+        export declare enum E {
+            a, b, c = 3,
+        }
+    }
+    namespace Merged {
+        export enum E {
+            a, b, 
+        }
+        export enum E {
+            c = 3, d,
+        }
+    }
+    
+    namespace Merged2 {
+        export enum E {
+            a, b, c
+        }
+        export module E {
+            export let d = 5;
+        }
+    }
+    
+    var abc: First.E;
+    var secondAbc: Abc.E;
+    var secondAbcd: Abcd.E;
+    var secondAb: Ab.E;
+    var secondCd: Cd.E;
+    var nope: Abc.Nope;
+    var k: Const.E;
+    var decl: Decl.E;
+    var merged: Merged.E;
+    var merged2: Merged2.E;
+    abc = secondAbc; // ok
+    abc = secondAbcd; // missing 'd'
+    ~~~
+!!! error TS2322: Type 'Abcd.E' is not assignable to type 'First.E'.
+!!! error TS2322:   Property 'd' is missing in type 'First.E'.
+    abc = secondAb; // ok
+    abc = secondCd; // missing 'd'
+    ~~~
+!!! error TS2322: Type 'Cd.E' is not assignable to type 'First.E'.
+!!! error TS2322:   Property 'd' is missing in type 'First.E'.
+    abc = nope; // nope!
+    ~~~
+!!! error TS2322: Type 'Nope' is not assignable to type 'E'.
+    abc = decl; // ok
+    secondAbc = abc; // ok
+    secondAbcd = abc; // ok
+    secondAb = abc; // missing 'c'
+    ~~~~~~~~
+!!! error TS2322: Type 'First.E' is not assignable to type 'Ab.E'.
+!!! error TS2322:   Property 'c' is missing in type 'Ab.E'.
+    secondCd = abc; // missing 'a' and 'b'
+    ~~~~~~~~
+!!! error TS2322: Type 'First.E' is not assignable to type 'Cd.E'.
+!!! error TS2322:   Property 'a' is missing in type 'Cd.E'.
+    nope = abc; // nope!
+    ~~~~
+!!! error TS2322: Type 'E' is not assignable to type 'Nope'.
+    decl = abc; // ok
+    
+    // const is only assignable to itself
+    k = k;
+    abc = k; // error
+    ~~~
+!!! error TS2322: Type 'Const.E' is not assignable to type 'First.E'.
+    k = abc;
+    ~
+!!! error TS2322: Type 'First.E' is not assignable to type 'Const.E'.
+    
+    // merged enums compare all their members
+    abc = merged; // missing 'd'
+    ~~~
+!!! error TS2322: Type 'Merged.E' is not assignable to type 'First.E'.
+!!! error TS2322:   Property 'd' is missing in type 'First.E'.
+    merged = abc; // ok
+    abc = merged2; // ok
+    merged2 = abc; // ok

tests/baselines/reference/enumAssignmentCompat3.js

@@ -0,0 +1,202 @@
+//// [enumAssignmentCompat3.ts]
+namespace First {
+    export enum E {
+        a, b, c,
+    }
+}
+namespace Abc {
+    export enum E {
+        a, b, c,
+    }
+    export enum Nope {
+        a, b, c,
+    }
+}
+namespace Abcd {
+    export enum E {
+        a, b, c, d,
+    }
+}
+namespace Ab {
+    export enum E {
+        a, b,
+    }
+}
+namespace Cd {
+    export enum E {
+        c, d,
+    }
+}
+namespace Const {
+    export const enum E {
+        a, b, c,
+    }
+}
+namespace Decl {
+    export declare enum E {
+        a, b, c = 3,
+    }
+}
+namespace Merged {
+    export enum E {
+        a, b, 
+    }
+    export enum E {
+        c = 3, d,
+    }
+}
+
+namespace Merged2 {
+    export enum E {
+        a, b, c
+    }
+    export module E {
+        export let d = 5;
+    }
+}
+
+var abc: First.E;
+var secondAbc: Abc.E;
+var secondAbcd: Abcd.E;
+var secondAb: Ab.E;
+var secondCd: Cd.E;
+var nope: Abc.Nope;
+var k: Const.E;
+var decl: Decl.E;
+var merged: Merged.E;
+var merged2: Merged2.E;
+abc = secondAbc; // ok
+abc = secondAbcd; // missing 'd'
+abc = secondAb; // ok
+abc = secondCd; // missing 'd'
+abc = nope; // nope!
+abc = decl; // ok
+secondAbc = abc; // ok
+secondAbcd = abc; // ok
+secondAb = abc; // missing 'c'
+secondCd = abc; // missing 'a' and 'b'
+nope = abc; // nope!
+decl = abc; // ok
+
+// const is only assignable to itself
+k = k;
+abc = k; // error
+k = abc;
+
+// merged enums compare all their members
+abc = merged; // missing 'd'
+merged = abc; // ok
+abc = merged2; // ok
+merged2 = abc; // ok
+
+//// [enumAssignmentCompat3.js]
+var First;
+(function (First) {
+    (function (E) {
+        E[E["a"] = 0] = "a";
+        E[E["b"] = 1] = "b";
+        E[E["c"] = 2] = "c";
+    })(First.E || (First.E = {}));
+    var E = First.E;
+})(First || (First = {}));
+var Abc;
+(function (Abc) {
+    (function (E) {
+        E[E["a"] = 0] = "a";
+        E[E["b"] = 1] = "b";
+        E[E["c"] = 2] = "c";
+    })(Abc.E || (Abc.E = {}));
+    var E = Abc.E;
+    (function (Nope) {
+        Nope[Nope["a"] = 0] = "a";
+        Nope[Nope["b"] = 1] = "b";
+        Nope[Nope["c"] = 2] = "c";
+    })(Abc.Nope || (Abc.Nope = {}));
+    var Nope = Abc.Nope;
+})(Abc || (Abc = {}));
+var Abcd;
+(function (Abcd) {
+    (function (E) {
+        E[E["a"] = 0] = "a";
+        E[E["b"] = 1] = "b";
+        E[E["c"] = 2] = "c";
+        E[E["d"] = 3] = "d";
+    })(Abcd.E || (Abcd.E = {}));
+    var E = Abcd.E;
+})(Abcd || (Abcd = {}));
+var Ab;
+(function (Ab) {
+    (function (E) {
+        E[E["a"] = 0] = "a";
+        E[E["b"] = 1] = "b";
+    })(Ab.E || (Ab.E = {}));
+    var E = Ab.E;
+})(Ab || (Ab = {}));
+var Cd;
+(function (Cd) {
+    (function (E) {
+        E[E["c"] = 0] = "c";
+        E[E["d"] = 1] = "d";
+    })(Cd.E || (Cd.E = {}));
+    var E = Cd.E;
+})(Cd || (Cd = {}));
+var Decl;
+(function (Decl) {
+})(Decl || (Decl = {}));
+var Merged;
+(function (Merged) {
+    (function (E) {
+        E[E["a"] = 0] = "a";
+        E[E["b"] = 1] = "b";
+    })(Merged.E || (Merged.E = {}));
+    var E = Merged.E;
+    (function (E) {
+        E[E["c"] = 3] = "c";
+        E[E["d"] = 4] = "d";
+    })(Merged.E || (Merged.E = {}));
+    var E = Merged.E;
+})(Merged || (Merged = {}));
+var Merged2;
+(function (Merged2) {
+    (function (E) {
+        E[E["a"] = 0] = "a";
+        E[E["b"] = 1] = "b";
+        E[E["c"] = 2] = "c";
+    })(Merged2.E || (Merged2.E = {}));
+    var E = Merged2.E;
+    var E;
+    (function (E) {
+        E.d = 5;
+    })(E = Merged2.E || (Merged2.E = {}));
+})(Merged2 || (Merged2 = {}));
+var abc;
+var secondAbc;
+var secondAbcd;
+var secondAb;
+var secondCd;
+var nope;
+var k;
+var decl;
+var merged;
+var merged2;
+abc = secondAbc; // ok
+abc = secondAbcd; // missing 'd'
+abc = secondAb; // ok
+abc = secondCd; // missing 'd'
+abc = nope; // nope!
+abc = decl; // ok
+secondAbc = abc; // ok
+secondAbcd = abc; // ok
+secondAb = abc; // missing 'c'
+secondCd = abc; // missing 'a' and 'b'
+nope = abc; // nope!
+decl = abc; // ok
+// const is only assignable to itself
+k = k;
+abc = k; // error
+k = abc;
+// merged enums compare all their members
+abc = merged; // missing 'd'
+merged = abc; // ok
+abc = merged2; // ok
+merged2 = abc; // ok

tests/baselines/reference/errorSuperCalls.errors.txt

@@ -1,12 +1,12 @@
 tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(4,9): error TS2335: 'super' can only be referenced in a derived class.
-tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(9,9): error TS2335: 'super' can only be referenced in a derived class.
-tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(14,9): error TS2335: 'super' can only be referenced in a derived class.
-tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(18,9): error TS2335: 'super' can only be referenced in a derived class.
-tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(22,9): error TS2335: 'super' can only be referenced in a derived class.
-tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(26,9): error TS2335: 'super' can only be referenced in a derived class.
-tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(30,16): error TS2335: 'super' can only be referenced in a derived class.
-tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(34,9): error TS2335: 'super' can only be referenced in a derived class.
-tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(38,9): error TS2335: 'super' can only be referenced in a derived class.
+tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(9,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
+tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(14,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
+tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(18,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
+tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(22,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
+tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(26,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
+tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(30,16): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
+tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(34,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
+tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(38,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
 tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(46,14): error TS1034: 'super' must be followed by an argument list or member access.
 tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(58,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
 tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(62,9): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
@@ -27,50 +27,50 @@ tests/cases/conformance/expressions/superCalls/errorSuperCalls.ts(71,9): error T
         fn() {
             super();
             ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
         }
     
         //super call in class accessor (get and set) with no base type
         get foo() {
             super();
             ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
             return null;
         }
         set foo(v) {
             super();
             ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
         }
     
         //super call in class member initializer with no base type
         p = super();
             ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
     
         //super call in static class member function with no base type
         static fn() {
             super();
             ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
         }
     
         //super call in static class member initializer with no base type
         static k = super();
                    ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
     
         //super call in static class accessor (get and set) with no base type
         static get q() {
             super();
             ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
             return null;
         }
         static set q(n) {
             super();
             ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
         }
     }
     

tests/baselines/reference/errorSuperPropertyAccess.errors.txt

@@ -15,8 +15,8 @@ tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess
 tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(65,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword.
 tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(68,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(69,19): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword.
-tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(73,13): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
-tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(76,40): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(73,13): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(76,40): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
 tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(87,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword.
 tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(91,23): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword.
 tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(94,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -34,8 +34,8 @@ tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess
 tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(120,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword.
 tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(121,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword.
 tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(122,9): error TS2341: Property 'privateStaticFunc' is private and only accessible within class 'SomeBase'.
-tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(127,16): error TS2335: 'super' can only be referenced in a derived class.
-tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(127,30): error TS2335: 'super' can only be referenced in a derived class.
+tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(127,16): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts(127,30): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
 
 
 ==== tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess.ts (38 errors) ====
@@ -147,12 +147,12 @@ tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess
             function inner() {
                 super.publicFunc();
                 ~~~~~
-!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
             }
             var x = {
                 test: function () { return super.publicFunc(); }
                                            ~~~~~
-!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
             }
         }
     }
@@ -239,7 +239,7 @@ tests/cases/conformance/expressions/superPropertyAccess/errorSuperPropertyAccess
     // In object literal
     var obj = { n: super.wat, p: super.foo() };
                    ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
                                  ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
     

tests/baselines/reference/functionOverloadCompatibilityWithVoid01.errors.txt

@@ -0,0 +1,10 @@
+tests/cases/conformance/functions/functionOverloadCompatibilityWithVoid01.ts(1,10): error TS2394: Overload signature is not compatible with function implementation.
+
+
+==== tests/cases/conformance/functions/functionOverloadCompatibilityWithVoid01.ts (1 errors) ====
+    function f(x: string): number;
+             ~
+!!! error TS2394: Overload signature is not compatible with function implementation.
+    function f(x: string): void {
+        return;
+    } 

tests/baselines/reference/functionOverloadCompatibilityWithVoid01.js

@@ -0,0 +1,10 @@
+//// [functionOverloadCompatibilityWithVoid01.ts]
+function f(x: string): number;
+function f(x: string): void {
+    return;
+} 
+
+//// [functionOverloadCompatibilityWithVoid01.js]
+function f(x) {
+    return;
+}

tests/baselines/reference/functionOverloadCompatibilityWithVoid02.js

@@ -0,0 +1,10 @@
+//// [functionOverloadCompatibilityWithVoid02.ts]
+function f(x: string): void;
+function f(x: string): number {
+    return 0;
+} 
+
+//// [functionOverloadCompatibilityWithVoid02.js]
+function f(x) {
+    return 0;
+}

tests/baselines/reference/functionOverloadCompatibilityWithVoid02.symbols

@@ -0,0 +1,11 @@
+=== tests/cases/conformance/functions/functionOverloadCompatibilityWithVoid02.ts ===
+function f(x: string): void;
+>f : Symbol(f, Decl(functionOverloadCompatibilityWithVoid02.ts, 0, 0), Decl(functionOverloadCompatibilityWithVoid02.ts, 0, 28))
+>x : Symbol(x, Decl(functionOverloadCompatibilityWithVoid02.ts, 0, 11))
+
+function f(x: string): number {
+>f : Symbol(f, Decl(functionOverloadCompatibilityWithVoid02.ts, 0, 0), Decl(functionOverloadCompatibilityWithVoid02.ts, 0, 28))
+>x : Symbol(x, Decl(functionOverloadCompatibilityWithVoid02.ts, 1, 11))
+
+    return 0;
+} 

tests/baselines/reference/functionOverloadCompatibilityWithVoid02.types

@@ -0,0 +1,12 @@
+=== tests/cases/conformance/functions/functionOverloadCompatibilityWithVoid02.ts ===
+function f(x: string): void;
+>f : (x: string) => void
+>x : string
+
+function f(x: string): number {
+>f : (x: string) => void
+>x : string
+
+    return 0;
+>0 : number
+} 

tests/baselines/reference/functionOverloadCompatibilityWithVoid03.js

@@ -0,0 +1,10 @@
+//// [functionOverloadCompatibilityWithVoid03.ts]
+function f(x: string): void;
+function f(x: string): void {
+    return;
+} 
+
+//// [functionOverloadCompatibilityWithVoid03.js]
+function f(x) {
+    return;
+}

tests/baselines/reference/functionOverloadCompatibilityWithVoid03.symbols

@@ -0,0 +1,11 @@
+=== tests/cases/conformance/functions/functionOverloadCompatibilityWithVoid03.ts ===
+function f(x: string): void;
+>f : Symbol(f, Decl(functionOverloadCompatibilityWithVoid03.ts, 0, 0), Decl(functionOverloadCompatibilityWithVoid03.ts, 0, 28))
+>x : Symbol(x, Decl(functionOverloadCompatibilityWithVoid03.ts, 0, 11))
+
+function f(x: string): void {
+>f : Symbol(f, Decl(functionOverloadCompatibilityWithVoid03.ts, 0, 0), Decl(functionOverloadCompatibilityWithVoid03.ts, 0, 28))
+>x : Symbol(x, Decl(functionOverloadCompatibilityWithVoid03.ts, 1, 11))
+
+    return;
+} 

tests/baselines/reference/functionOverloadCompatibilityWithVoid03.types

@@ -0,0 +1,11 @@
+=== tests/cases/conformance/functions/functionOverloadCompatibilityWithVoid03.ts ===
+function f(x: string): void;
+>f : (x: string) => void
+>x : string
+
+function f(x: string): void {
+>f : (x: string) => void
+>x : string
+
+    return;
+} 

tests/baselines/reference/functionOverloads22.errors.txt

@@ -1,10 +0,0 @@
-tests/cases/compiler/functionOverloads22.ts(2,10): error TS2394: Overload signature is not compatible with function implementation.
-
-
-==== tests/cases/compiler/functionOverloads22.ts (1 errors) ====
-    function foo(bar:number):{a:number;}[];
-    function foo(bar:string):{a:number; b:string;}[];
-             ~~~
-!!! error TS2394: Overload signature is not compatible with function implementation.
-    function foo(bar:any):{a:any;b?:any;}[] { return [{a:""}] }
-    

tests/baselines/reference/functionOverloads22.symbols

@@ -0,0 +1,19 @@
+=== tests/cases/compiler/functionOverloads22.ts ===
+function foo(bar:number):{a:number;}[];
+>foo : Symbol(foo, Decl(functionOverloads22.ts, 0, 0), Decl(functionOverloads22.ts, 0, 39), Decl(functionOverloads22.ts, 1, 49))
+>bar : Symbol(bar, Decl(functionOverloads22.ts, 0, 13))
+>a : Symbol(a, Decl(functionOverloads22.ts, 0, 26))
+
+function foo(bar:string):{a:number; b:string;}[];
+>foo : Symbol(foo, Decl(functionOverloads22.ts, 0, 0), Decl(functionOverloads22.ts, 0, 39), Decl(functionOverloads22.ts, 1, 49))
+>bar : Symbol(bar, Decl(functionOverloads22.ts, 1, 13))
+>a : Symbol(a, Decl(functionOverloads22.ts, 1, 26))
+>b : Symbol(b, Decl(functionOverloads22.ts, 1, 35))
+
+function foo(bar:any):{a:any;b?:any;}[] { return [{a:""}] }
+>foo : Symbol(foo, Decl(functionOverloads22.ts, 0, 0), Decl(functionOverloads22.ts, 0, 39), Decl(functionOverloads22.ts, 1, 49))
+>bar : Symbol(bar, Decl(functionOverloads22.ts, 2, 13))
+>a : Symbol(a, Decl(functionOverloads22.ts, 2, 23))
+>b : Symbol(b, Decl(functionOverloads22.ts, 2, 29))
+>a : Symbol(a, Decl(functionOverloads22.ts, 2, 51))
+

tests/baselines/reference/functionOverloads22.types

@@ -0,0 +1,22 @@
+=== tests/cases/compiler/functionOverloads22.ts ===
+function foo(bar:number):{a:number;}[];
+>foo : { (bar: number): { a: number; }[]; (bar: string): { a: number; b: string; }[]; }
+>bar : number
+>a : number
+
+function foo(bar:string):{a:number; b:string;}[];
+>foo : { (bar: number): { a: number; }[]; (bar: string): { a: number; b: string; }[]; }
+>bar : string
+>a : number
+>b : string
+
+function foo(bar:any):{a:any;b?:any;}[] { return [{a:""}] }
+>foo : { (bar: number): { a: number; }[]; (bar: string): { a: number; b: string; }[]; }
+>bar : any
+>a : any
+>b : any
+>[{a:""}] : { a: string; }[]
+>{a:""} : { a: string; }
+>a : string
+>"" : string
+

tests/baselines/reference/functionOverloads43.js

@@ -0,0 +1,24 @@
+//// [functionOverloads43.ts]
+function foo(bar: { a:number }[]): number;
+function foo(bar: { a:string }[]): string;
+function foo([x]: { a:number | string }[]): string | number {
+    if (x) {
+        return x.a;
+    }
+    
+    return undefined;
+}
+
+var x = foo([{a: "str"}]);
+var y = foo([{a: 100}]);
+
+//// [functionOverloads43.js]
+function foo(_a) {
+    var x = _a[0];
+    if (x) {
+        return x.a;
+    }
+    return undefined;
+}
+var x = foo([{ a: "str" }]);
+var y = foo([{ a: 100 }]);

tests/baselines/reference/functionOverloads43.symbols

@@ -0,0 +1,39 @@
+=== tests/cases/compiler/functionOverloads43.ts ===
+function foo(bar: { a:number }[]): number;
+>foo : Symbol(foo, Decl(functionOverloads43.ts, 0, 0), Decl(functionOverloads43.ts, 0, 42), Decl(functionOverloads43.ts, 1, 42))
+>bar : Symbol(bar, Decl(functionOverloads43.ts, 0, 13))
+>a : Symbol(a, Decl(functionOverloads43.ts, 0, 19))
+
+function foo(bar: { a:string }[]): string;
+>foo : Symbol(foo, Decl(functionOverloads43.ts, 0, 0), Decl(functionOverloads43.ts, 0, 42), Decl(functionOverloads43.ts, 1, 42))
+>bar : Symbol(bar, Decl(functionOverloads43.ts, 1, 13))
+>a : Symbol(a, Decl(functionOverloads43.ts, 1, 19))
+
+function foo([x]: { a:number | string }[]): string | number {
+>foo : Symbol(foo, Decl(functionOverloads43.ts, 0, 0), Decl(functionOverloads43.ts, 0, 42), Decl(functionOverloads43.ts, 1, 42))
+>x : Symbol(x, Decl(functionOverloads43.ts, 2, 14))
+>a : Symbol(a, Decl(functionOverloads43.ts, 2, 19))
+
+    if (x) {
+>x : Symbol(x, Decl(functionOverloads43.ts, 2, 14))
+
+        return x.a;
+>x.a : Symbol(a, Decl(functionOverloads43.ts, 2, 19))
+>x : Symbol(x, Decl(functionOverloads43.ts, 2, 14))
+>a : Symbol(a, Decl(functionOverloads43.ts, 2, 19))
+    }
+    
+    return undefined;
+>undefined : Symbol(undefined)
+}
+
+var x = foo([{a: "str"}]);
+>x : Symbol(x, Decl(functionOverloads43.ts, 10, 3))
+>foo : Symbol(foo, Decl(functionOverloads43.ts, 0, 0), Decl(functionOverloads43.ts, 0, 42), Decl(functionOverloads43.ts, 1, 42))
+>a : Symbol(a, Decl(functionOverloads43.ts, 10, 14))
+
+var y = foo([{a: 100}]);
+>y : Symbol(y, Decl(functionOverloads43.ts, 11, 3))
+>foo : Symbol(foo, Decl(functionOverloads43.ts, 0, 0), Decl(functionOverloads43.ts, 0, 42), Decl(functionOverloads43.ts, 1, 42))
+>a : Symbol(a, Decl(functionOverloads43.ts, 11, 14))
+

tests/baselines/reference/functionOverloads43.types

@@ -0,0 +1,47 @@
+=== tests/cases/compiler/functionOverloads43.ts ===
+function foo(bar: { a:number }[]): number;
+>foo : { (bar: { a: number; }[]): number; (bar: { a: string; }[]): string; }
+>bar : { a: number; }[]
+>a : number
+
+function foo(bar: { a:string }[]): string;
+>foo : { (bar: { a: number; }[]): number; (bar: { a: string; }[]): string; }
+>bar : { a: string; }[]
+>a : string
+
+function foo([x]: { a:number | string }[]): string | number {
+>foo : { (bar: { a: number; }[]): number; (bar: { a: string; }[]): string; }
+>x : { a: number | string; }
+>a : number | string
+
+    if (x) {
+>x : { a: number | string; }
+
+        return x.a;
+>x.a : number | string
+>x : { a: number | string; }
+>a : number | string
+    }
+    
+    return undefined;
+>undefined : undefined
+}
+
+var x = foo([{a: "str"}]);
+>x : string
+>foo([{a: "str"}]) : string
+>foo : { (bar: { a: number; }[]): number; (bar: { a: string; }[]): string; }
+>[{a: "str"}] : { a: string; }[]
+>{a: "str"} : { a: string; }
+>a : string
+>"str" : string
+
+var y = foo([{a: 100}]);
+>y : number
+>foo([{a: 100}]) : number
+>foo : { (bar: { a: number; }[]): number; (bar: { a: string; }[]): string; }
+>[{a: 100}] : { a: number; }[]
+>{a: 100} : { a: number; }
+>a : number
+>100 : number
+

tests/baselines/reference/functionOverloads44.js

@@ -0,0 +1,37 @@
+//// [functionOverloads44.ts]
+interface Animal { animal }
+interface Dog extends Animal { dog }
+interface Cat extends Animal { cat }
+
+function foo1(bar: { a:number }[]): Dog;
+function foo1(bar: { a:string }[]): Animal;
+function foo1([x]: { a:number | string }[]): Dog {
+    return undefined;
+}
+
+function foo2(bar: { a:number }[]): Cat;
+function foo2(bar: { a:string }[]): Cat | Dog;
+function foo2([x]: { a:number | string }[]): Cat {
+    return undefined;
+}
+
+
+var x1 = foo1([{a: "str"}]);
+var y1 = foo1([{a: 100}]);
+
+var x2 = foo2([{a: "str"}]);
+var y2 = foo2([{a: 100}]);
+
+//// [functionOverloads44.js]
+function foo1(_a) {
+    var x = _a[0];
+    return undefined;
+}
+function foo2(_a) {
+    var x = _a[0];
+    return undefined;
+}
+var x1 = foo1([{ a: "str" }]);
+var y1 = foo1([{ a: 100 }]);
+var x2 = foo2([{ a: "str" }]);
+var y2 = foo2([{ a: 100 }]);

tests/baselines/reference/functionOverloads44.symbols

@@ -0,0 +1,81 @@
+=== tests/cases/compiler/functionOverloads44.ts ===
+interface Animal { animal }
+>Animal : Symbol(Animal, Decl(functionOverloads44.ts, 0, 0))
+>animal : Symbol(animal, Decl(functionOverloads44.ts, 0, 18))
+
+interface Dog extends Animal { dog }
+>Dog : Symbol(Dog, Decl(functionOverloads44.ts, 0, 27))
+>Animal : Symbol(Animal, Decl(functionOverloads44.ts, 0, 0))
+>dog : Symbol(dog, Decl(functionOverloads44.ts, 1, 30))
+
+interface Cat extends Animal { cat }
+>Cat : Symbol(Cat, Decl(functionOverloads44.ts, 1, 36))
+>Animal : Symbol(Animal, Decl(functionOverloads44.ts, 0, 0))
+>cat : Symbol(cat, Decl(functionOverloads44.ts, 2, 30))
+
+function foo1(bar: { a:number }[]): Dog;
+>foo1 : Symbol(foo1, Decl(functionOverloads44.ts, 2, 36), Decl(functionOverloads44.ts, 4, 40), Decl(functionOverloads44.ts, 5, 43))
+>bar : Symbol(bar, Decl(functionOverloads44.ts, 4, 14))
+>a : Symbol(a, Decl(functionOverloads44.ts, 4, 20))
+>Dog : Symbol(Dog, Decl(functionOverloads44.ts, 0, 27))
+
+function foo1(bar: { a:string }[]): Animal;
+>foo1 : Symbol(foo1, Decl(functionOverloads44.ts, 2, 36), Decl(functionOverloads44.ts, 4, 40), Decl(functionOverloads44.ts, 5, 43))
+>bar : Symbol(bar, Decl(functionOverloads44.ts, 5, 14))
+>a : Symbol(a, Decl(functionOverloads44.ts, 5, 20))
+>Animal : Symbol(Animal, Decl(functionOverloads44.ts, 0, 0))
+
+function foo1([x]: { a:number | string }[]): Dog {
+>foo1 : Symbol(foo1, Decl(functionOverloads44.ts, 2, 36), Decl(functionOverloads44.ts, 4, 40), Decl(functionOverloads44.ts, 5, 43))
+>x : Symbol(x, Decl(functionOverloads44.ts, 6, 15))
+>a : Symbol(a, Decl(functionOverloads44.ts, 6, 20))
+>Dog : Symbol(Dog, Decl(functionOverloads44.ts, 0, 27))
+
+    return undefined;
+>undefined : Symbol(undefined)
+}
+
+function foo2(bar: { a:number }[]): Cat;
+>foo2 : Symbol(foo2, Decl(functionOverloads44.ts, 8, 1), Decl(functionOverloads44.ts, 10, 40), Decl(functionOverloads44.ts, 11, 46))
+>bar : Symbol(bar, Decl(functionOverloads44.ts, 10, 14))
+>a : Symbol(a, Decl(functionOverloads44.ts, 10, 20))
+>Cat : Symbol(Cat, Decl(functionOverloads44.ts, 1, 36))
+
+function foo2(bar: { a:string }[]): Cat | Dog;
+>foo2 : Symbol(foo2, Decl(functionOverloads44.ts, 8, 1), Decl(functionOverloads44.ts, 10, 40), Decl(functionOverloads44.ts, 11, 46))
+>bar : Symbol(bar, Decl(functionOverloads44.ts, 11, 14))
+>a : Symbol(a, Decl(functionOverloads44.ts, 11, 20))
+>Cat : Symbol(Cat, Decl(functionOverloads44.ts, 1, 36))
+>Dog : Symbol(Dog, Decl(functionOverloads44.ts, 0, 27))
+
+function foo2([x]: { a:number | string }[]): Cat {
+>foo2 : Symbol(foo2, Decl(functionOverloads44.ts, 8, 1), Decl(functionOverloads44.ts, 10, 40), Decl(functionOverloads44.ts, 11, 46))
+>x : Symbol(x, Decl(functionOverloads44.ts, 12, 15))
+>a : Symbol(a, Decl(functionOverloads44.ts, 12, 20))
+>Cat : Symbol(Cat, Decl(functionOverloads44.ts, 1, 36))
+
+    return undefined;
+>undefined : Symbol(undefined)
+}
+
+
+var x1 = foo1([{a: "str"}]);
+>x1 : Symbol(x1, Decl(functionOverloads44.ts, 17, 3))
+>foo1 : Symbol(foo1, Decl(functionOverloads44.ts, 2, 36), Decl(functionOverloads44.ts, 4, 40), Decl(functionOverloads44.ts, 5, 43))
+>a : Symbol(a, Decl(functionOverloads44.ts, 17, 16))
+
+var y1 = foo1([{a: 100}]);
+>y1 : Symbol(y1, Decl(functionOverloads44.ts, 18, 3))
+>foo1 : Symbol(foo1, Decl(functionOverloads44.ts, 2, 36), Decl(functionOverloads44.ts, 4, 40), Decl(functionOverloads44.ts, 5, 43))
+>a : Symbol(a, Decl(functionOverloads44.ts, 18, 16))
+
+var x2 = foo2([{a: "str"}]);
+>x2 : Symbol(x2, Decl(functionOverloads44.ts, 20, 3))
+>foo2 : Symbol(foo2, Decl(functionOverloads44.ts, 8, 1), Decl(functionOverloads44.ts, 10, 40), Decl(functionOverloads44.ts, 11, 46))
+>a : Symbol(a, Decl(functionOverloads44.ts, 20, 16))
+
+var y2 = foo2([{a: 100}]);
+>y2 : Symbol(y2, Decl(functionOverloads44.ts, 21, 3))
+>foo2 : Symbol(foo2, Decl(functionOverloads44.ts, 8, 1), Decl(functionOverloads44.ts, 10, 40), Decl(functionOverloads44.ts, 11, 46))
+>a : Symbol(a, Decl(functionOverloads44.ts, 21, 16))
+

tests/baselines/reference/functionOverloads44.types

@@ -0,0 +1,97 @@
+=== tests/cases/compiler/functionOverloads44.ts ===
+interface Animal { animal }
+>Animal : Animal
+>animal : any
+
+interface Dog extends Animal { dog }
+>Dog : Dog
+>Animal : Animal
+>dog : any
+
+interface Cat extends Animal { cat }
+>Cat : Cat
+>Animal : Animal
+>cat : any
+
+function foo1(bar: { a:number }[]): Dog;
+>foo1 : { (bar: { a: number; }[]): Dog; (bar: { a: string; }[]): Animal; }
+>bar : { a: number; }[]
+>a : number
+>Dog : Dog
+
+function foo1(bar: { a:string }[]): Animal;
+>foo1 : { (bar: { a: number; }[]): Dog; (bar: { a: string; }[]): Animal; }
+>bar : { a: string; }[]
+>a : string
+>Animal : Animal
+
+function foo1([x]: { a:number | string }[]): Dog {
+>foo1 : { (bar: { a: number; }[]): Dog; (bar: { a: string; }[]): Animal; }
+>x : { a: number | string; }
+>a : number | string
+>Dog : Dog
+
+    return undefined;
+>undefined : undefined
+}
+
+function foo2(bar: { a:number }[]): Cat;
+>foo2 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Cat | Dog; }
+>bar : { a: number; }[]
+>a : number
+>Cat : Cat
+
+function foo2(bar: { a:string }[]): Cat | Dog;
+>foo2 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Cat | Dog; }
+>bar : { a: string; }[]
+>a : string
+>Cat : Cat
+>Dog : Dog
+
+function foo2([x]: { a:number | string }[]): Cat {
+>foo2 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Cat | Dog; }
+>x : { a: number | string; }
+>a : number | string
+>Cat : Cat
+
+    return undefined;
+>undefined : undefined
+}
+
+
+var x1 = foo1([{a: "str"}]);
+>x1 : Animal
+>foo1([{a: "str"}]) : Animal
+>foo1 : { (bar: { a: number; }[]): Dog; (bar: { a: string; }[]): Animal; }
+>[{a: "str"}] : { a: string; }[]
+>{a: "str"} : { a: string; }
+>a : string
+>"str" : string
+
+var y1 = foo1([{a: 100}]);
+>y1 : Dog
+>foo1([{a: 100}]) : Dog
+>foo1 : { (bar: { a: number; }[]): Dog; (bar: { a: string; }[]): Animal; }
+>[{a: 100}] : { a: number; }[]
+>{a: 100} : { a: number; }
+>a : number
+>100 : number
+
+var x2 = foo2([{a: "str"}]);
+>x2 : Cat | Dog
+>foo2([{a: "str"}]) : Cat | Dog
+>foo2 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Cat | Dog; }
+>[{a: "str"}] : { a: string; }[]
+>{a: "str"} : { a: string; }
+>a : string
+>"str" : string
+
+var y2 = foo2([{a: 100}]);
+>y2 : Cat
+>foo2([{a: 100}]) : Cat
+>foo2 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Cat | Dog; }
+>[{a: 100}] : { a: number; }[]
+>{a: 100} : { a: number; }
+>a : number
+>100 : number
+

tests/baselines/reference/functionOverloads45.js

@@ -0,0 +1,37 @@
+//// [functionOverloads45.ts]
+interface Animal { animal }
+interface Dog extends Animal { dog }
+interface Cat extends Animal { cat }
+
+function foo1(bar: { a:number }[]): Cat;
+function foo1(bar: { a:string }[]): Dog;
+function foo1([x]: { a:number | string }[]): Animal {
+    return undefined;
+}
+
+function foo2(bar: { a:number }[]): Cat;
+function foo2(bar: { a:string }[]): Dog;
+function foo2([x]: { a:number | string }[]): Cat | Dog {
+    return undefined;
+}
+
+
+var x1 = foo1([{a: "str"}]);
+var y1 = foo1([{a: 100}]);
+
+var x2 = foo2([{a: "str"}]);
+var y2 = foo2([{a: 100}]);
+
+//// [functionOverloads45.js]
+function foo1(_a) {
+    var x = _a[0];
+    return undefined;
+}
+function foo2(_a) {
+    var x = _a[0];
+    return undefined;
+}
+var x1 = foo1([{ a: "str" }]);
+var y1 = foo1([{ a: 100 }]);
+var x2 = foo2([{ a: "str" }]);
+var y2 = foo2([{ a: 100 }]);

tests/baselines/reference/functionOverloads45.symbols

@@ -0,0 +1,81 @@
+=== tests/cases/compiler/functionOverloads45.ts ===
+interface Animal { animal }
+>Animal : Symbol(Animal, Decl(functionOverloads45.ts, 0, 0))
+>animal : Symbol(animal, Decl(functionOverloads45.ts, 0, 18))
+
+interface Dog extends Animal { dog }
+>Dog : Symbol(Dog, Decl(functionOverloads45.ts, 0, 27))
+>Animal : Symbol(Animal, Decl(functionOverloads45.ts, 0, 0))
+>dog : Symbol(dog, Decl(functionOverloads45.ts, 1, 30))
+
+interface Cat extends Animal { cat }
+>Cat : Symbol(Cat, Decl(functionOverloads45.ts, 1, 36))
+>Animal : Symbol(Animal, Decl(functionOverloads45.ts, 0, 0))
+>cat : Symbol(cat, Decl(functionOverloads45.ts, 2, 30))
+
+function foo1(bar: { a:number }[]): Cat;
+>foo1 : Symbol(foo1, Decl(functionOverloads45.ts, 2, 36), Decl(functionOverloads45.ts, 4, 40), Decl(functionOverloads45.ts, 5, 40))
+>bar : Symbol(bar, Decl(functionOverloads45.ts, 4, 14))
+>a : Symbol(a, Decl(functionOverloads45.ts, 4, 20))
+>Cat : Symbol(Cat, Decl(functionOverloads45.ts, 1, 36))
+
+function foo1(bar: { a:string }[]): Dog;
+>foo1 : Symbol(foo1, Decl(functionOverloads45.ts, 2, 36), Decl(functionOverloads45.ts, 4, 40), Decl(functionOverloads45.ts, 5, 40))
+>bar : Symbol(bar, Decl(functionOverloads45.ts, 5, 14))
+>a : Symbol(a, Decl(functionOverloads45.ts, 5, 20))
+>Dog : Symbol(Dog, Decl(functionOverloads45.ts, 0, 27))
+
+function foo1([x]: { a:number | string }[]): Animal {
+>foo1 : Symbol(foo1, Decl(functionOverloads45.ts, 2, 36), Decl(functionOverloads45.ts, 4, 40), Decl(functionOverloads45.ts, 5, 40))
+>x : Symbol(x, Decl(functionOverloads45.ts, 6, 15))
+>a : Symbol(a, Decl(functionOverloads45.ts, 6, 20))
+>Animal : Symbol(Animal, Decl(functionOverloads45.ts, 0, 0))
+
+    return undefined;
+>undefined : Symbol(undefined)
+}
+
+function foo2(bar: { a:number }[]): Cat;
+>foo2 : Symbol(foo2, Decl(functionOverloads45.ts, 8, 1), Decl(functionOverloads45.ts, 10, 40), Decl(functionOverloads45.ts, 11, 40))
+>bar : Symbol(bar, Decl(functionOverloads45.ts, 10, 14))
+>a : Symbol(a, Decl(functionOverloads45.ts, 10, 20))
+>Cat : Symbol(Cat, Decl(functionOverloads45.ts, 1, 36))
+
+function foo2(bar: { a:string }[]): Dog;
+>foo2 : Symbol(foo2, Decl(functionOverloads45.ts, 8, 1), Decl(functionOverloads45.ts, 10, 40), Decl(functionOverloads45.ts, 11, 40))
+>bar : Symbol(bar, Decl(functionOverloads45.ts, 11, 14))
+>a : Symbol(a, Decl(functionOverloads45.ts, 11, 20))
+>Dog : Symbol(Dog, Decl(functionOverloads45.ts, 0, 27))
+
+function foo2([x]: { a:number | string }[]): Cat | Dog {
+>foo2 : Symbol(foo2, Decl(functionOverloads45.ts, 8, 1), Decl(functionOverloads45.ts, 10, 40), Decl(functionOverloads45.ts, 11, 40))
+>x : Symbol(x, Decl(functionOverloads45.ts, 12, 15))
+>a : Symbol(a, Decl(functionOverloads45.ts, 12, 20))
+>Cat : Symbol(Cat, Decl(functionOverloads45.ts, 1, 36))
+>Dog : Symbol(Dog, Decl(functionOverloads45.ts, 0, 27))
+
+    return undefined;
+>undefined : Symbol(undefined)
+}
+
+
+var x1 = foo1([{a: "str"}]);
+>x1 : Symbol(x1, Decl(functionOverloads45.ts, 17, 3))
+>foo1 : Symbol(foo1, Decl(functionOverloads45.ts, 2, 36), Decl(functionOverloads45.ts, 4, 40), Decl(functionOverloads45.ts, 5, 40))
+>a : Symbol(a, Decl(functionOverloads45.ts, 17, 16))
+
+var y1 = foo1([{a: 100}]);
+>y1 : Symbol(y1, Decl(functionOverloads45.ts, 18, 3))
+>foo1 : Symbol(foo1, Decl(functionOverloads45.ts, 2, 36), Decl(functionOverloads45.ts, 4, 40), Decl(functionOverloads45.ts, 5, 40))
+>a : Symbol(a, Decl(functionOverloads45.ts, 18, 16))
+
+var x2 = foo2([{a: "str"}]);
+>x2 : Symbol(x2, Decl(functionOverloads45.ts, 20, 3))
+>foo2 : Symbol(foo2, Decl(functionOverloads45.ts, 8, 1), Decl(functionOverloads45.ts, 10, 40), Decl(functionOverloads45.ts, 11, 40))
+>a : Symbol(a, Decl(functionOverloads45.ts, 20, 16))
+
+var y2 = foo2([{a: 100}]);
+>y2 : Symbol(y2, Decl(functionOverloads45.ts, 21, 3))
+>foo2 : Symbol(foo2, Decl(functionOverloads45.ts, 8, 1), Decl(functionOverloads45.ts, 10, 40), Decl(functionOverloads45.ts, 11, 40))
+>a : Symbol(a, Decl(functionOverloads45.ts, 21, 16))
+

tests/baselines/reference/functionOverloads45.types

@@ -0,0 +1,97 @@
+=== tests/cases/compiler/functionOverloads45.ts ===
+interface Animal { animal }
+>Animal : Animal
+>animal : any
+
+interface Dog extends Animal { dog }
+>Dog : Dog
+>Animal : Animal
+>dog : any
+
+interface Cat extends Animal { cat }
+>Cat : Cat
+>Animal : Animal
+>cat : any
+
+function foo1(bar: { a:number }[]): Cat;
+>foo1 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Dog; }
+>bar : { a: number; }[]
+>a : number
+>Cat : Cat
+
+function foo1(bar: { a:string }[]): Dog;
+>foo1 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Dog; }
+>bar : { a: string; }[]
+>a : string
+>Dog : Dog
+
+function foo1([x]: { a:number | string }[]): Animal {
+>foo1 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Dog; }
+>x : { a: number | string; }
+>a : number | string
+>Animal : Animal
+
+    return undefined;
+>undefined : undefined
+}
+
+function foo2(bar: { a:number }[]): Cat;
+>foo2 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Dog; }
+>bar : { a: number; }[]
+>a : number
+>Cat : Cat
+
+function foo2(bar: { a:string }[]): Dog;
+>foo2 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Dog; }
+>bar : { a: string; }[]
+>a : string
+>Dog : Dog
+
+function foo2([x]: { a:number | string }[]): Cat | Dog {
+>foo2 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Dog; }
+>x : { a: number | string; }
+>a : number | string
+>Cat : Cat
+>Dog : Dog
+
+    return undefined;
+>undefined : undefined
+}
+
+
+var x1 = foo1([{a: "str"}]);
+>x1 : Dog
+>foo1([{a: "str"}]) : Dog
+>foo1 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Dog; }
+>[{a: "str"}] : { a: string; }[]
+>{a: "str"} : { a: string; }
+>a : string
+>"str" : string
+
+var y1 = foo1([{a: 100}]);
+>y1 : Cat
+>foo1([{a: 100}]) : Cat
+>foo1 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Dog; }
+>[{a: 100}] : { a: number; }[]
+>{a: 100} : { a: number; }
+>a : number
+>100 : number
+
+var x2 = foo2([{a: "str"}]);
+>x2 : Dog
+>foo2([{a: "str"}]) : Dog
+>foo2 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Dog; }
+>[{a: "str"}] : { a: string; }[]
+>{a: "str"} : { a: string; }
+>a : string
+>"str" : string
+
+var y2 = foo2([{a: 100}]);
+>y2 : Cat
+>foo2([{a: 100}]) : Cat
+>foo2 : { (bar: { a: number; }[]): Cat; (bar: { a: string; }[]): Dog; }
+>[{a: 100}] : { a: number; }[]
+>{a: 100} : { a: number; }
+>a : number
+>100 : number
+

tests/baselines/reference/overloadOnConstConstraintChecks4.errors.txt

@@ -1,19 +0,0 @@
-tests/cases/compiler/overloadOnConstConstraintChecks4.ts(9,10): error TS2394: Overload signature is not compatible with function implementation.
-
-
-==== tests/cases/compiler/overloadOnConstConstraintChecks4.ts (1 errors) ====
-    class Z { }
-    class A extends Z { private x = 1 }
-    class B extends A {}
-    class C extends A {
-        public foo() { }
-    }
-    function foo(name: 'hi'): B;
-    function foo(name: 'bye'): C;
-    function foo(name: string): A; // error
-             ~~~
-!!! error TS2394: Overload signature is not compatible with function implementation.
-    function foo(name: any): Z {
-        return null;
-    }
-    

tests/baselines/reference/overloadOnConstConstraintChecks4.js

@@ -7,7 +7,7 @@ class C extends A {
 }
 function foo(name: 'hi'): B;
 function foo(name: 'bye'): C;
-function foo(name: string): A; // error
+function foo(name: string): A;
 function foo(name: any): Z {
     return null;
 }

tests/baselines/reference/overloadOnConstConstraintChecks4.symbols

@@ -0,0 +1,43 @@
+=== tests/cases/compiler/overloadOnConstConstraintChecks4.ts ===
+class Z { }
+>Z : Symbol(Z, Decl(overloadOnConstConstraintChecks4.ts, 0, 0))
+
+class A extends Z { private x = 1 }
+>A : Symbol(A, Decl(overloadOnConstConstraintChecks4.ts, 0, 11))
+>Z : Symbol(Z, Decl(overloadOnConstConstraintChecks4.ts, 0, 0))
+>x : Symbol(x, Decl(overloadOnConstConstraintChecks4.ts, 1, 19))
+
+class B extends A {}
+>B : Symbol(B, Decl(overloadOnConstConstraintChecks4.ts, 1, 35))
+>A : Symbol(A, Decl(overloadOnConstConstraintChecks4.ts, 0, 11))
+
+class C extends A {
+>C : Symbol(C, Decl(overloadOnConstConstraintChecks4.ts, 2, 20))
+>A : Symbol(A, Decl(overloadOnConstConstraintChecks4.ts, 0, 11))
+
+    public foo() { }
+>foo : Symbol(foo, Decl(overloadOnConstConstraintChecks4.ts, 3, 19))
+}
+function foo(name: 'hi'): B;
+>foo : Symbol(foo, Decl(overloadOnConstConstraintChecks4.ts, 5, 1), Decl(overloadOnConstConstraintChecks4.ts, 6, 28), Decl(overloadOnConstConstraintChecks4.ts, 7, 29), Decl(overloadOnConstConstraintChecks4.ts, 8, 30))
+>name : Symbol(name, Decl(overloadOnConstConstraintChecks4.ts, 6, 13))
+>B : Symbol(B, Decl(overloadOnConstConstraintChecks4.ts, 1, 35))
+
+function foo(name: 'bye'): C;
+>foo : Symbol(foo, Decl(overloadOnConstConstraintChecks4.ts, 5, 1), Decl(overloadOnConstConstraintChecks4.ts, 6, 28), Decl(overloadOnConstConstraintChecks4.ts, 7, 29), Decl(overloadOnConstConstraintChecks4.ts, 8, 30))
+>name : Symbol(name, Decl(overloadOnConstConstraintChecks4.ts, 7, 13))
+>C : Symbol(C, Decl(overloadOnConstConstraintChecks4.ts, 2, 20))
+
+function foo(name: string): A;
+>foo : Symbol(foo, Decl(overloadOnConstConstraintChecks4.ts, 5, 1), Decl(overloadOnConstConstraintChecks4.ts, 6, 28), Decl(overloadOnConstConstraintChecks4.ts, 7, 29), Decl(overloadOnConstConstraintChecks4.ts, 8, 30))
+>name : Symbol(name, Decl(overloadOnConstConstraintChecks4.ts, 8, 13))
+>A : Symbol(A, Decl(overloadOnConstConstraintChecks4.ts, 0, 11))
+
+function foo(name: any): Z {
+>foo : Symbol(foo, Decl(overloadOnConstConstraintChecks4.ts, 5, 1), Decl(overloadOnConstConstraintChecks4.ts, 6, 28), Decl(overloadOnConstConstraintChecks4.ts, 7, 29), Decl(overloadOnConstConstraintChecks4.ts, 8, 30))
+>name : Symbol(name, Decl(overloadOnConstConstraintChecks4.ts, 9, 13))
+>Z : Symbol(Z, Decl(overloadOnConstConstraintChecks4.ts, 0, 0))
+
+    return null;
+}
+

tests/baselines/reference/overloadOnConstConstraintChecks4.types

@@ -0,0 +1,45 @@
+=== tests/cases/compiler/overloadOnConstConstraintChecks4.ts ===
+class Z { }
+>Z : Z
+
+class A extends Z { private x = 1 }
+>A : A
+>Z : Z
+>x : number
+>1 : number
+
+class B extends A {}
+>B : B
+>A : A
+
+class C extends A {
+>C : C
+>A : A
+
+    public foo() { }
+>foo : () => void
+}
+function foo(name: 'hi'): B;
+>foo : { (name: "hi"): B; (name: "bye"): C; (name: string): A; }
+>name : "hi"
+>B : B
+
+function foo(name: 'bye'): C;
+>foo : { (name: "hi"): B; (name: "bye"): C; (name: string): A; }
+>name : "bye"
+>C : C
+
+function foo(name: string): A;
+>foo : { (name: "hi"): B; (name: "bye"): C; (name: string): A; }
+>name : string
+>A : A
+
+function foo(name: any): Z {
+>foo : { (name: "hi"): B; (name: "bye"): C; (name: string): A; }
+>name : any
+>Z : Z
+
+    return null;
+>null : null
+}
+

tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.js

@@ -0,0 +1,58 @@
+//// [prefixUnaryOperatorsOnExportedVariables.ts]
+
+export var x = false;
+export var y = 1;
+if (!x) {
+    
+}
+
+if (+x) {
+    
+}
+
+if (-x) {
+    
+}
+
+if (~x) {
+    
+}
+
+if (void x) {
+    
+}
+
+if (typeof x) {
+    
+}
+
+if (++y) {
+    
+}
+
+//// [prefixUnaryOperatorsOnExportedVariables.js]
+System.register([], function(exports_1) {
+    "use strict";
+    var x, y;
+    return {
+        setters:[],
+        execute: function() {
+            exports_1("x", x = false);
+            exports_1("y", y = 1);
+            if (!x) {
+            }
+            if (+x) {
+            }
+            if (-x) {
+            }
+            if (~x) {
+            }
+            if (void x) {
+            }
+            if (typeof x) {
+            }
+            if (exports_1("y", ++y)) {
+            }
+        }
+    }
+});

tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.symbols

@@ -0,0 +1,42 @@
+=== tests/cases/compiler/prefixUnaryOperatorsOnExportedVariables.ts ===
+
+export var x = false;
+>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10))
+
+export var y = 1;
+>y : Symbol(y, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 2, 10))
+
+if (!x) {
+>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10))
+    
+}
+
+if (+x) {
+>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10))
+    
+}
+
+if (-x) {
+>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10))
+    
+}
+
+if (~x) {
+>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10))
+    
+}
+
+if (void x) {
+>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10))
+    
+}
+
+if (typeof x) {
+>x : Symbol(x, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 1, 10))
+    
+}
+
+if (++y) {
+>y : Symbol(y, Decl(prefixUnaryOperatorsOnExportedVariables.ts, 2, 10))
+    
+}

tests/baselines/reference/prefixUnaryOperatorsOnExportedVariables.types

@@ -0,0 +1,51 @@
+=== tests/cases/compiler/prefixUnaryOperatorsOnExportedVariables.ts ===
+
+export var x = false;
+>x : boolean
+>false : boolean
+
+export var y = 1;
+>y : number
+>1 : number
+
+if (!x) {
+>!x : boolean
+>x : boolean
+    
+}
+
+if (+x) {
+>+x : number
+>x : boolean
+    
+}
+
+if (-x) {
+>-x : number
+>x : boolean
+    
+}
+
+if (~x) {
+>~x : number
+>x : boolean
+    
+}
+
+if (void x) {
+>void x : undefined
+>x : boolean
+    
+}
+
+if (typeof x) {
+>typeof x : string
+>x : boolean
+    
+}
+
+if (++y) {
+>++y : number
+>y : number
+    
+}

tests/baselines/reference/stringLiteralTypesAsTags01.js

@@ -20,7 +20,7 @@ function hasKind(entity: Entity, kind: "A"): entity is A;
 function hasKind(entity: Entity, kind: "B"): entity is B;
 function hasKind(entity: Entity, kind: Kind): entity is Entity;
 function hasKind(entity: Entity, kind: Kind): boolean {
-    return kind === is;
+    return entity.kind === kind;
 }
 
 let x: A = {
@@ -44,7 +44,7 @@ else {
 
 //// [stringLiteralTypesAsTags01.js]
 function hasKind(entity, kind) {
-    return kind === is;
+    return entity.kind === kind;
 }
 var x = {
     kind: "A",

tests/baselines/reference/stringLiteralTypesAsTags01.symbols

@@ -0,0 +1,112 @@
+=== tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts ===
+
+type Kind = "A" | "B"
+>Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags01.ts, 0, 0))
+
+interface Entity {
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21))
+
+    kind: Kind;
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 3, 18))
+>Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags01.ts, 0, 0))
+}
+
+interface A extends Entity {
+>A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 5, 1))
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21))
+
+    kind: "A";
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 7, 28))
+
+    a: number;
+>a : Symbol(a, Decl(stringLiteralTypesAsTags01.ts, 8, 14))
+}
+
+interface B extends Entity {
+>B : Symbol(B, Decl(stringLiteralTypesAsTags01.ts, 10, 1))
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21))
+
+    kind: "B";
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 12, 28))
+
+    b: string;
+>b : Symbol(b, Decl(stringLiteralTypesAsTags01.ts, 13, 14))
+}
+
+function hasKind(entity: Entity, kind: "A"): entity is A;
+>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 17, 17))
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21))
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 17, 32))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 17, 17))
+>A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 5, 1))
+
+function hasKind(entity: Entity, kind: "B"): entity is B;
+>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 18, 17))
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21))
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 18, 32))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 18, 17))
+>B : Symbol(B, Decl(stringLiteralTypesAsTags01.ts, 10, 1))
+
+function hasKind(entity: Entity, kind: Kind): entity is Entity;
+>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 19, 17))
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21))
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 19, 32))
+>Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags01.ts, 0, 0))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 19, 17))
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21))
+
+function hasKind(entity: Entity, kind: Kind): boolean {
+>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 20, 17))
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags01.ts, 1, 21))
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 20, 32))
+>Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags01.ts, 0, 0))
+
+    return entity.kind === kind;
+>entity.kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags01.ts, 3, 18))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags01.ts, 20, 17))
+>kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags01.ts, 3, 18))
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 20, 32))
+}
+
+let x: A = {
+>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3))
+>A : Symbol(A, Decl(stringLiteralTypesAsTags01.ts, 5, 1))
+
+    kind: "A",
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags01.ts, 24, 12))
+
+    a: 100,
+>a : Symbol(a, Decl(stringLiteralTypesAsTags01.ts, 25, 14))
+}
+
+if (hasKind(x, "A")) {
+>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63))
+>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3))
+
+    let a = x;
+>a : Symbol(a, Decl(stringLiteralTypesAsTags01.ts, 30, 7))
+>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3))
+}
+else {
+    let b = x;
+>b : Symbol(b, Decl(stringLiteralTypesAsTags01.ts, 33, 7))
+>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3))
+}
+
+if (!hasKind(x, "B")) {
+>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags01.ts, 15, 1), Decl(stringLiteralTypesAsTags01.ts, 17, 57), Decl(stringLiteralTypesAsTags01.ts, 18, 57), Decl(stringLiteralTypesAsTags01.ts, 19, 63))
+>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3))
+
+    let c = x;
+>c : Symbol(c, Decl(stringLiteralTypesAsTags01.ts, 37, 7))
+>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3))
+}
+else {
+    let d = x;
+>d : Symbol(d, Decl(stringLiteralTypesAsTags01.ts, 40, 7))
+>x : Symbol(x, Decl(stringLiteralTypesAsTags01.ts, 24, 3))
+}

tests/baselines/reference/stringLiteralTypesAsTags01.types

@@ -0,0 +1,121 @@
+=== tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts ===
+
+type Kind = "A" | "B"
+>Kind : "A" | "B"
+
+interface Entity {
+>Entity : Entity
+
+    kind: Kind;
+>kind : "A" | "B"
+>Kind : "A" | "B"
+}
+
+interface A extends Entity {
+>A : A
+>Entity : Entity
+
+    kind: "A";
+>kind : "A"
+
+    a: number;
+>a : number
+}
+
+interface B extends Entity {
+>B : B
+>Entity : Entity
+
+    kind: "B";
+>kind : "B"
+
+    b: string;
+>b : string
+}
+
+function hasKind(entity: Entity, kind: "A"): entity is A;
+>hasKind : { (entity: Entity, kind: "A"): entity is A; (entity: Entity, kind: "B"): entity is B; (entity: Entity, kind: "A" | "B"): entity is Entity; }
+>entity : Entity
+>Entity : Entity
+>kind : "A"
+>entity : any
+>A : A
+
+function hasKind(entity: Entity, kind: "B"): entity is B;
+>hasKind : { (entity: Entity, kind: "A"): entity is A; (entity: Entity, kind: "B"): entity is B; (entity: Entity, kind: "A" | "B"): entity is Entity; }
+>entity : Entity
+>Entity : Entity
+>kind : "B"
+>entity : any
+>B : B
+
+function hasKind(entity: Entity, kind: Kind): entity is Entity;
+>hasKind : { (entity: Entity, kind: "A"): entity is A; (entity: Entity, kind: "B"): entity is B; (entity: Entity, kind: "A" | "B"): entity is Entity; }
+>entity : Entity
+>Entity : Entity
+>kind : "A" | "B"
+>Kind : "A" | "B"
+>entity : any
+>Entity : Entity
+
+function hasKind(entity: Entity, kind: Kind): boolean {
+>hasKind : { (entity: Entity, kind: "A"): entity is A; (entity: Entity, kind: "B"): entity is B; (entity: Entity, kind: "A" | "B"): entity is Entity; }
+>entity : Entity
+>Entity : Entity
+>kind : "A" | "B"
+>Kind : "A" | "B"
+
+    return entity.kind === kind;
+>entity.kind === kind : boolean
+>entity.kind : "A" | "B"
+>entity : Entity
+>kind : "A" | "B"
+>kind : "A" | "B"
+}
+
+let x: A = {
+>x : A
+>A : A
+>{    kind: "A",    a: 100,} : { kind: "A"; a: number; }
+
+    kind: "A",
+>kind : "A"
+>"A" : "A"
+
+    a: 100,
+>a : number
+>100 : number
+}
+
+if (hasKind(x, "A")) {
+>hasKind(x, "A") : entity is A
+>hasKind : { (entity: Entity, kind: "A"): entity is A; (entity: Entity, kind: "B"): entity is B; (entity: Entity, kind: "A" | "B"): entity is Entity; }
+>x : A
+>"A" : "A"
+
+    let a = x;
+>a : A
+>x : A
+}
+else {
+    let b = x;
+>b : A
+>x : A
+}
+
+if (!hasKind(x, "B")) {
+>!hasKind(x, "B") : boolean
+>hasKind(x, "B") : entity is B
+>hasKind : { (entity: Entity, kind: "A"): entity is A; (entity: Entity, kind: "B"): entity is B; (entity: Entity, kind: "A" | "B"): entity is Entity; }
+>x : A
+>"B" : "B"
+
+    let c = x;
+>c : A
+>x : A
+}
+else {
+    let d = x;
+>d : A
+>x : A
+}

tests/baselines/reference/stringLiteralTypesAsTags02.errors.txt

@@ -1,8 +1,8 @@
-tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts(20,10): error TS2394: Overload signature is not compatible with function implementation.
-tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts(22,21): error TS2304: Cannot find name 'is'.
+tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags02.ts(18,10): error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
+tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags02.ts(19,10): error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
 
 
-==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts (2 errors) ====
+==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags02.ts (2 errors) ====
     
     type Kind = "A" | "B"
     
@@ -21,14 +21,13 @@ tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts(22,21)
     }
     
     function hasKind(entity: Entity, kind: "A"): entity is A;
-    function hasKind(entity: Entity, kind: "B"): entity is B;
-    function hasKind(entity: Entity, kind: Kind): entity is Entity;
              ~~~~~~~
-!!! error TS2394: Overload signature is not compatible with function implementation.
-    function hasKind(entity: Entity, kind: Kind): boolean {
-        return kind === is;
-                        ~~
-!!! error TS2304: Cannot find name 'is'.
+!!! error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
+    function hasKind(entity: Entity, kind: "B"): entity is B;
+             ~~~~~~~
+!!! error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
+    function hasKind(entity: Entity, kind: Kind): entity is (A | B) {
+        return entity.kind === kind;
     }
     
     let x: A = {

tests/baselines/reference/stringLiteralTypesAsTags02.js

@@ -0,0 +1,81 @@
+//// [stringLiteralTypesAsTags02.ts]
+
+type Kind = "A" | "B"
+
+interface Entity {
+    kind: Kind;
+}
+
+interface A extends Entity {
+    kind: "A";
+    a: number;
+}
+
+interface B extends Entity {
+    kind: "B";
+    b: string;
+}
+
+function hasKind(entity: Entity, kind: "A"): entity is A;
+function hasKind(entity: Entity, kind: "B"): entity is B;
+function hasKind(entity: Entity, kind: Kind): entity is (A | B) {
+    return entity.kind === kind;
+}
+
+let x: A = {
+    kind: "A",
+    a: 100,
+}
+
+if (hasKind(x, "A")) {
+    let a = x;
+}
+else {
+    let b = x;
+}
+
+if (!hasKind(x, "B")) {
+    let c = x;
+}
+else {
+    let d = x;
+}
+
+//// [stringLiteralTypesAsTags02.js]
+function hasKind(entity, kind) {
+    return entity.kind === kind;
+}
+var x = {
+    kind: "A",
+    a: 100
+};
+if (hasKind(x, "A")) {
+    var a = x;
+}
+else {
+    var b = x;
+}
+if (!hasKind(x, "B")) {
+    var c = x;
+}
+else {
+    var d = x;
+}
+
+
+//// [stringLiteralTypesAsTags02.d.ts]
+declare type Kind = "A" | "B";
+interface Entity {
+    kind: Kind;
+}
+interface A extends Entity {
+    kind: "A";
+    a: number;
+}
+interface B extends Entity {
+    kind: "B";
+    b: string;
+}
+declare function hasKind(entity: Entity, kind: "A"): entity is A;
+declare function hasKind(entity: Entity, kind: "B"): entity is B;
+declare let x: A;

tests/baselines/reference/stringLiteralTypesAsTags03.js

@@ -0,0 +1,85 @@
+//// [stringLiteralTypesAsTags03.ts]
+
+type Kind = "A" | "B"
+
+interface Entity {
+    kind: Kind;
+}
+
+interface A extends Entity {
+    kind: "A";
+    a: number;
+}
+
+interface B extends Entity {
+    kind: "B";
+    b: string;
+}
+
+// Currently (2015-12-14), we write '"A" | "A"' and '"B" | "B"' to avoid
+// interpreting respective overloads as "specialized" signatures.
+// That way, we can avoid the need to look for a compatible overload
+// signature and simply check compatibility with the implementation.
+function hasKind(entity: Entity, kind: "A" | "A"): entity is A;
+function hasKind(entity: Entity, kind: "B" | "B"): entity is B;
+function hasKind(entity: Entity, kind: Kind): entity is Entity {
+    return entity.kind === kind;
+}
+
+let x: A = {
+    kind: "A",
+    a: 100,
+}
+
+if (hasKind(x, "A")) {
+    let a = x;
+}
+else {
+    let b = x;
+}
+
+if (!hasKind(x, "B")) {
+    let c = x;
+}
+else {
+    let d = x;
+}
+
+//// [stringLiteralTypesAsTags03.js]
+function hasKind(entity, kind) {
+    return entity.kind === kind;
+}
+var x = {
+    kind: "A",
+    a: 100
+};
+if (hasKind(x, "A")) {
+    var a = x;
+}
+else {
+    var b = x;
+}
+if (!hasKind(x, "B")) {
+    var c = x;
+}
+else {
+    var d = x;
+}
+
+
+//// [stringLiteralTypesAsTags03.d.ts]
+declare type Kind = "A" | "B";
+interface Entity {
+    kind: Kind;
+}
+interface A extends Entity {
+    kind: "A";
+    a: number;
+}
+interface B extends Entity {
+    kind: "B";
+    b: string;
+}
+declare function hasKind(entity: Entity, kind: "A" | "A"): entity is A;
+declare function hasKind(entity: Entity, kind: "B" | "B"): entity is B;
+declare let x: A;

tests/baselines/reference/stringLiteralTypesAsTags03.symbols

@@ -0,0 +1,109 @@
+=== tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags03.ts ===
+
+type Kind = "A" | "B"
+>Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags03.ts, 0, 0))
+
+interface Entity {
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21))
+
+    kind: Kind;
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 3, 18))
+>Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags03.ts, 0, 0))
+}
+
+interface A extends Entity {
+>A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 5, 1))
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21))
+
+    kind: "A";
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 7, 28))
+
+    a: number;
+>a : Symbol(a, Decl(stringLiteralTypesAsTags03.ts, 8, 14))
+}
+
+interface B extends Entity {
+>B : Symbol(B, Decl(stringLiteralTypesAsTags03.ts, 10, 1))
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21))
+
+    kind: "B";
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 12, 28))
+
+    b: string;
+>b : Symbol(b, Decl(stringLiteralTypesAsTags03.ts, 13, 14))
+}
+
+// Currently (2015-12-14), we write '"A" | "A"' and '"B" | "B"' to avoid
+// interpreting respective overloads as "specialized" signatures.
+// That way, we can avoid the need to look for a compatible overload
+// signature and simply check compatibility with the implementation.
+function hasKind(entity: Entity, kind: "A" | "A"): entity is A;
+>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 21, 17))
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21))
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 21, 32))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 21, 17))
+>A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 5, 1))
+
+function hasKind(entity: Entity, kind: "B" | "B"): entity is B;
+>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 22, 17))
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21))
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 22, 32))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 22, 17))
+>B : Symbol(B, Decl(stringLiteralTypesAsTags03.ts, 10, 1))
+
+function hasKind(entity: Entity, kind: Kind): entity is Entity {
+>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 23, 17))
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21))
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 23, 32))
+>Kind : Symbol(Kind, Decl(stringLiteralTypesAsTags03.ts, 0, 0))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 23, 17))
+>Entity : Symbol(Entity, Decl(stringLiteralTypesAsTags03.ts, 1, 21))
+
+    return entity.kind === kind;
+>entity.kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags03.ts, 3, 18))
+>entity : Symbol(entity, Decl(stringLiteralTypesAsTags03.ts, 23, 17))
+>kind : Symbol(Entity.kind, Decl(stringLiteralTypesAsTags03.ts, 3, 18))
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 23, 32))
+}
+
+let x: A = {
+>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3))
+>A : Symbol(A, Decl(stringLiteralTypesAsTags03.ts, 5, 1))
+
+    kind: "A",
+>kind : Symbol(kind, Decl(stringLiteralTypesAsTags03.ts, 27, 12))
+
+    a: 100,
+>a : Symbol(a, Decl(stringLiteralTypesAsTags03.ts, 28, 14))
+}
+
+if (hasKind(x, "A")) {
+>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63))
+>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3))
+
+    let a = x;
+>a : Symbol(a, Decl(stringLiteralTypesAsTags03.ts, 33, 7))
+>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3))
+}
+else {
+    let b = x;
+>b : Symbol(b, Decl(stringLiteralTypesAsTags03.ts, 36, 7))
+>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3))
+}
+
+if (!hasKind(x, "B")) {
+>hasKind : Symbol(hasKind, Decl(stringLiteralTypesAsTags03.ts, 15, 1), Decl(stringLiteralTypesAsTags03.ts, 21, 63), Decl(stringLiteralTypesAsTags03.ts, 22, 63))
+>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3))
+
+    let c = x;
+>c : Symbol(c, Decl(stringLiteralTypesAsTags03.ts, 40, 7))
+>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3))
+}
+else {
+    let d = x;
+>d : Symbol(d, Decl(stringLiteralTypesAsTags03.ts, 43, 7))
+>x : Symbol(x, Decl(stringLiteralTypesAsTags03.ts, 27, 3))
+}

tests/baselines/reference/stringLiteralTypesAsTags03.types

@@ -0,0 +1,118 @@
+=== tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags03.ts ===
+
+type Kind = "A" | "B"
+>Kind : "A" | "B"
+
+interface Entity {
+>Entity : Entity
+
+    kind: Kind;
+>kind : "A" | "B"
+>Kind : "A" | "B"
+}
+
+interface A extends Entity {
+>A : A
+>Entity : Entity
+
+    kind: "A";
+>kind : "A"
+
+    a: number;
+>a : number
+}
+
+interface B extends Entity {
+>B : B
+>Entity : Entity
+
+    kind: "B";
+>kind : "B"
+
+    b: string;
+>b : string
+}
+
+// Currently (2015-12-14), we write '"A" | "A"' and '"B" | "B"' to avoid
+// interpreting respective overloads as "specialized" signatures.
+// That way, we can avoid the need to look for a compatible overload
+// signature and simply check compatibility with the implementation.
+function hasKind(entity: Entity, kind: "A" | "A"): entity is A;
+>hasKind : { (entity: Entity, kind: "A"): entity is A; (entity: Entity, kind: "B"): entity is B; }
+>entity : Entity
+>Entity : Entity
+>kind : "A"
+>entity : any
+>A : A
+
+function hasKind(entity: Entity, kind: "B" | "B"): entity is B;
+>hasKind : { (entity: Entity, kind: "A"): entity is A; (entity: Entity, kind: "B"): entity is B; }
+>entity : Entity
+>Entity : Entity
+>kind : "B"
+>entity : any
+>B : B
+
+function hasKind(entity: Entity, kind: Kind): entity is Entity {
+>hasKind : { (entity: Entity, kind: "A"): entity is A; (entity: Entity, kind: "B"): entity is B; }
+>entity : Entity
+>Entity : Entity
+>kind : "A" | "B"
+>Kind : "A" | "B"
+>entity : any
+>Entity : Entity
+
+    return entity.kind === kind;
+>entity.kind === kind : boolean
+>entity.kind : "A" | "B"
+>entity : Entity
+>kind : "A" | "B"
+>kind : "A" | "B"
+}
+
+let x: A = {
+>x : A
+>A : A
+>{    kind: "A",    a: 100,} : { kind: "A"; a: number; }
+
+    kind: "A",
+>kind : "A"
+>"A" : "A"
+
+    a: 100,
+>a : number
+>100 : number
+}
+
+if (hasKind(x, "A")) {
+>hasKind(x, "A") : entity is A
+>hasKind : { (entity: Entity, kind: "A"): entity is A; (entity: Entity, kind: "B"): entity is B; }
+>x : A
+>"A" : "A"
+
+    let a = x;
+>a : A
+>x : A
+}
+else {
+    let b = x;
+>b : A
+>x : A
+}
+
+if (!hasKind(x, "B")) {
+>!hasKind(x, "B") : boolean
+>hasKind(x, "B") : entity is B
+>hasKind : { (entity: Entity, kind: "A"): entity is A; (entity: Entity, kind: "B"): entity is B; }
+>x : A
+>"B" : "B"
+
+    let c = x;
+>c : A
+>x : A
+}
+else {
+    let d = x;
+>d : A
+>x : A
+}

tests/baselines/reference/stringLiteralTypesOverloads01.errors.txt

@@ -1,59 +0,0 @@
-tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads01.ts(11,10): error TS2354: No best common type exists among return expressions.
-
-
-==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads01.ts (1 errors) ====
-    
-    type PrimitiveName = 'string' | 'number' | 'boolean';
-    
-    function getFalsyPrimitive(x: "string"): string;
-    function getFalsyPrimitive(x: "number"): number;
-    function getFalsyPrimitive(x: "boolean"): boolean;
-    function getFalsyPrimitive(x: "boolean" | "string"): boolean | string;
-    function getFalsyPrimitive(x: "boolean" | "number"): boolean | number;
-    function getFalsyPrimitive(x: "number" | "string"): number | string;
-    function getFalsyPrimitive(x: "number" | "string" | "boolean"): number | string | boolean;
-    function getFalsyPrimitive(x: PrimitiveName) {
-             ~~~~~~~~~~~~~~~~~
-!!! error TS2354: No best common type exists among return expressions.
-        if (x === "string") {
-            return "";
-        }
-        if (x === "number") {
-            return 0;
-        }
-        if (x === "boolean") {
-            return false;
-        }
-    
-        // Should be unreachable.
-        throw "Invalid value";
-    }
-    
-    namespace Consts1 {
-        const EMPTY_STRING = getFalsyPrimitive("string");
-        const ZERO = getFalsyPrimitive('number');
-        const FALSE = getFalsyPrimitive("boolean");
-    }
-    
-    const string: "string" = "string"
-    const number: "number" = "number"
-    const boolean: "boolean" = "boolean"
-    
-    const stringOrNumber = string || number;
-    const stringOrBoolean = string || boolean;
-    const booleanOrNumber = number || boolean;
-    const stringOrBooleanOrNumber = stringOrBoolean || number;
-    
-    namespace Consts2 {
-        const EMPTY_STRING = getFalsyPrimitive(string);
-        const ZERO = getFalsyPrimitive(number);
-        const FALSE = getFalsyPrimitive(boolean);
-    
-        const a = getFalsyPrimitive(stringOrNumber);
-        const b = getFalsyPrimitive(stringOrBoolean);
-        const c = getFalsyPrimitive(booleanOrNumber);
-        const d = getFalsyPrimitive(stringOrBooleanOrNumber);
-    }
-    
-    
-    

tests/baselines/reference/stringLiteralTypesOverloads01.js

@@ -9,7 +9,7 @@ function getFalsyPrimitive(x: "boolean" | "string"): boolean | string;
 function getFalsyPrimitive(x: "boolean" | "number"): boolean | number;
 function getFalsyPrimitive(x: "number" | "string"): number | string;
 function getFalsyPrimitive(x: "number" | "string" | "boolean"): number | string | boolean;
-function getFalsyPrimitive(x: PrimitiveName) {
+function getFalsyPrimitive(x: PrimitiveName): number | string | boolean {
     if (x === "string") {
         return "";
     }

tests/baselines/reference/stringLiteralTypesOverloads01.symbols

@@ -0,0 +1,144 @@
+=== tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads01.ts ===
+
+type PrimitiveName = 'string' | 'number' | 'boolean';
+>PrimitiveName : Symbol(PrimitiveName, Decl(stringLiteralTypesOverloads01.ts, 0, 0))
+
+function getFalsyPrimitive(x: "string"): string;
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 3, 27))
+
+function getFalsyPrimitive(x: "number"): number;
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 4, 27))
+
+function getFalsyPrimitive(x: "boolean"): boolean;
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 5, 27))
+
+function getFalsyPrimitive(x: "boolean" | "string"): boolean | string;
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 6, 27))
+
+function getFalsyPrimitive(x: "boolean" | "number"): boolean | number;
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 7, 27))
+
+function getFalsyPrimitive(x: "number" | "string"): number | string;
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 8, 27))
+
+function getFalsyPrimitive(x: "number" | "string" | "boolean"): number | string | boolean;
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 9, 27))
+
+function getFalsyPrimitive(x: PrimitiveName): number | string | boolean {
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 10, 27))
+>PrimitiveName : Symbol(PrimitiveName, Decl(stringLiteralTypesOverloads01.ts, 0, 0))
+
+    if (x === "string") {
+>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 10, 27))
+
+        return "";
+    }
+    if (x === "number") {
+>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 10, 27))
+
+        return 0;
+    }
+    if (x === "boolean") {
+>x : Symbol(x, Decl(stringLiteralTypesOverloads01.ts, 10, 27))
+
+        return false;
+    }
+
+    // Should be unreachable.
+    throw "Invalid value";
+}
+
+namespace Consts1 {
+>Consts1 : Symbol(Consts1, Decl(stringLiteralTypesOverloads01.ts, 23, 1))
+
+    const EMPTY_STRING = getFalsyPrimitive("string");
+>EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads01.ts, 26, 9))
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+
+    const ZERO = getFalsyPrimitive('number');
+>ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads01.ts, 27, 9))
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+
+    const FALSE = getFalsyPrimitive("boolean");
+>FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads01.ts, 28, 9))
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+}
+
+const string: "string" = "string"
+>string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 31, 5))
+
+const number: "number" = "number"
+>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5))
+
+const boolean: "boolean" = "boolean"
+>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 33, 5))
+
+const stringOrNumber = string || number;
+>stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads01.ts, 35, 5))
+>string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 31, 5))
+>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5))
+
+const stringOrBoolean = string || boolean;
+>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 36, 5))
+>string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 31, 5))
+>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 33, 5))
+
+const booleanOrNumber = number || boolean;
+>booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 37, 5))
+>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5))
+>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 33, 5))
+
+const stringOrBooleanOrNumber = stringOrBoolean || number;
+>stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 38, 5))
+>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 36, 5))
+>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5))
+
+namespace Consts2 {
+>Consts2 : Symbol(Consts2, Decl(stringLiteralTypesOverloads01.ts, 38, 58))
+
+    const EMPTY_STRING = getFalsyPrimitive(string);
+>EMPTY_STRING : Symbol(EMPTY_STRING, Decl(stringLiteralTypesOverloads01.ts, 41, 9))
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>string : Symbol(string, Decl(stringLiteralTypesOverloads01.ts, 31, 5))
+
+    const ZERO = getFalsyPrimitive(number);
+>ZERO : Symbol(ZERO, Decl(stringLiteralTypesOverloads01.ts, 42, 9))
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>number : Symbol(number, Decl(stringLiteralTypesOverloads01.ts, 32, 5))
+
+    const FALSE = getFalsyPrimitive(boolean);
+>FALSE : Symbol(FALSE, Decl(stringLiteralTypesOverloads01.ts, 43, 9))
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>boolean : Symbol(boolean, Decl(stringLiteralTypesOverloads01.ts, 33, 5))
+
+    const a = getFalsyPrimitive(stringOrNumber);
+>a : Symbol(a, Decl(stringLiteralTypesOverloads01.ts, 45, 9))
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>stringOrNumber : Symbol(stringOrNumber, Decl(stringLiteralTypesOverloads01.ts, 35, 5))
+
+    const b = getFalsyPrimitive(stringOrBoolean);
+>b : Symbol(b, Decl(stringLiteralTypesOverloads01.ts, 46, 9))
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>stringOrBoolean : Symbol(stringOrBoolean, Decl(stringLiteralTypesOverloads01.ts, 36, 5))
+
+    const c = getFalsyPrimitive(booleanOrNumber);
+>c : Symbol(c, Decl(stringLiteralTypesOverloads01.ts, 47, 9))
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>booleanOrNumber : Symbol(booleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 37, 5))
+
+    const d = getFalsyPrimitive(stringOrBooleanOrNumber);
+>d : Symbol(d, Decl(stringLiteralTypesOverloads01.ts, 48, 9))
+>getFalsyPrimitive : Symbol(getFalsyPrimitive, Decl(stringLiteralTypesOverloads01.ts, 1, 53), Decl(stringLiteralTypesOverloads01.ts, 3, 48), Decl(stringLiteralTypesOverloads01.ts, 4, 48), Decl(stringLiteralTypesOverloads01.ts, 5, 50), Decl(stringLiteralTypesOverloads01.ts, 6, 70), Decl(stringLiteralTypesOverloads01.ts, 7, 70), Decl(stringLiteralTypesOverloads01.ts, 8, 68), Decl(stringLiteralTypesOverloads01.ts, 9, 90))
+>stringOrBooleanOrNumber : Symbol(stringOrBooleanOrNumber, Decl(stringLiteralTypesOverloads01.ts, 38, 5))
+}
+
+
+

tests/baselines/reference/stringLiteralTypesOverloads01.types

@@ -0,0 +1,174 @@
+=== tests/cases/conformance/types/stringLiteral/stringLiteralTypesOverloads01.ts ===
+
+type PrimitiveName = 'string' | 'number' | 'boolean';
+>PrimitiveName : "string" | "number" | "boolean"
+
+function getFalsyPrimitive(x: "string"): string;
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>x : "string"
+
+function getFalsyPrimitive(x: "number"): number;
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>x : "number"
+
+function getFalsyPrimitive(x: "boolean"): boolean;
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>x : "boolean"
+
+function getFalsyPrimitive(x: "boolean" | "string"): boolean | string;
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>x : "boolean" | "string"
+
+function getFalsyPrimitive(x: "boolean" | "number"): boolean | number;
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>x : "boolean" | "number"
+
+function getFalsyPrimitive(x: "number" | "string"): number | string;
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>x : "number" | "string"
+
+function getFalsyPrimitive(x: "number" | "string" | "boolean"): number | string | boolean;
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>x : "number" | "string" | "boolean"
+
+function getFalsyPrimitive(x: PrimitiveName): number | string | boolean {
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>x : "string" | "number" | "boolean"
+>PrimitiveName : "string" | "number" | "boolean"
+
+    if (x === "string") {
+>x === "string" : boolean
+>x : "string" | "number" | "boolean"
+>"string" : string
+
+        return "";
+>"" : string
+    }
+    if (x === "number") {
+>x === "number" : boolean
+>x : "string" | "number" | "boolean"
+>"number" : string
+
+        return 0;
+>0 : number
+    }
+    if (x === "boolean") {
+>x === "boolean" : boolean
+>x : "string" | "number" | "boolean"
+>"boolean" : string
+
+        return false;
+>false : boolean
+    }
+
+    // Should be unreachable.
+    throw "Invalid value";
+>"Invalid value" : string
+}
+
+namespace Consts1 {
+>Consts1 : typeof Consts1
+
+    const EMPTY_STRING = getFalsyPrimitive("string");
+>EMPTY_STRING : string
+>getFalsyPrimitive("string") : string
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>"string" : "string"
+
+    const ZERO = getFalsyPrimitive('number');
+>ZERO : number
+>getFalsyPrimitive('number') : number
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>'number' : "number"
+
+    const FALSE = getFalsyPrimitive("boolean");
+>FALSE : boolean
+>getFalsyPrimitive("boolean") : boolean
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>"boolean" : "boolean"
+}
+
+const string: "string" = "string"
+>string : "string"
+>"string" : "string"
+
+const number: "number" = "number"
+>number : "number"
+>"number" : "number"
+
+const boolean: "boolean" = "boolean"
+>boolean : "boolean"
+>"boolean" : "boolean"
+
+const stringOrNumber = string || number;
+>stringOrNumber : "string" | "number"
+>string || number : "string" | "number"
+>string : "string"
+>number : "number"
+
+const stringOrBoolean = string || boolean;
+>stringOrBoolean : "string" | "boolean"
+>string || boolean : "string" | "boolean"
+>string : "string"
+>boolean : "boolean"
+
+const booleanOrNumber = number || boolean;
+>booleanOrNumber : "number" | "boolean"
+>number || boolean : "number" | "boolean"
+>number : "number"
+>boolean : "boolean"
+
+const stringOrBooleanOrNumber = stringOrBoolean || number;
+>stringOrBooleanOrNumber : "string" | "boolean" | "number"
+>stringOrBoolean || number : "string" | "boolean" | "number"
+>stringOrBoolean : "string" | "boolean"
+>number : "number"
+
+namespace Consts2 {
+>Consts2 : typeof Consts2
+
+    const EMPTY_STRING = getFalsyPrimitive(string);
+>EMPTY_STRING : string
+>getFalsyPrimitive(string) : string
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>string : "string"
+
+    const ZERO = getFalsyPrimitive(number);
+>ZERO : number
+>getFalsyPrimitive(number) : number
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>number : "number"
+
+    const FALSE = getFalsyPrimitive(boolean);
+>FALSE : boolean
+>getFalsyPrimitive(boolean) : boolean
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>boolean : "boolean"
+
+    const a = getFalsyPrimitive(stringOrNumber);
+>a : number | string
+>getFalsyPrimitive(stringOrNumber) : number | string
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>stringOrNumber : "string" | "number"
+
+    const b = getFalsyPrimitive(stringOrBoolean);
+>b : boolean | string
+>getFalsyPrimitive(stringOrBoolean) : boolean | string
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>stringOrBoolean : "string" | "boolean"
+
+    const c = getFalsyPrimitive(booleanOrNumber);
+>c : boolean | number
+>getFalsyPrimitive(booleanOrNumber) : boolean | number
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>booleanOrNumber : "number" | "boolean"
+
+    const d = getFalsyPrimitive(stringOrBooleanOrNumber);
+>d : number | string | boolean
+>getFalsyPrimitive(stringOrBooleanOrNumber) : number | string | boolean
+>getFalsyPrimitive : { (x: "string"): string; (x: "number"): number; (x: "boolean"): boolean; (x: "boolean" | "string"): boolean | string; (x: "boolean" | "number"): boolean | number; (x: "number" | "string"): number | string; (x: "number" | "string" | "boolean"): number | string | boolean; }
+>stringOrBooleanOrNumber : "string" | "boolean" | "number"
+}
+
+
+

tests/baselines/reference/superCallFromFunction1.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/compiler/superCallFromFunction1.ts(3,5): error TS2335: 'super' can only be referenced in a derived class.
+tests/cases/compiler/superCallFromFunction1.ts(3,5): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
 
 
 ==== tests/cases/compiler/superCallFromFunction1.ts (1 errors) ====
@@ -6,5 +6,5 @@ tests/cases/compiler/superCallFromFunction1.ts(3,5): error TS2335: 'super' can o
     function foo() {
         super(value => String(value));
         ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors.
     }

tests/baselines/reference/superErrors.errors.txt

@@ -1,15 +1,15 @@
-tests/cases/compiler/superErrors.ts(3,13): error TS2335: 'super' can only be referenced in a derived class.
+tests/cases/compiler/superErrors.ts(3,13): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
 tests/cases/compiler/superErrors.ts(3,18): error TS1034: 'super' must be followed by an argument list or member access.
-tests/cases/compiler/superErrors.ts(4,19): error TS2335: 'super' can only be referenced in a derived class.
+tests/cases/compiler/superErrors.ts(4,19): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
 tests/cases/compiler/superErrors.ts(4,24): error TS1034: 'super' must be followed by an argument list or member access.
-tests/cases/compiler/superErrors.ts(5,31): error TS2335: 'super' can only be referenced in a derived class.
+tests/cases/compiler/superErrors.ts(5,31): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
 tests/cases/compiler/superErrors.ts(5,36): error TS1034: 'super' must be followed by an argument list or member access.
-tests/cases/compiler/superErrors.ts(22,13): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
-tests/cases/compiler/superErrors.ts(27,27): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
-tests/cases/compiler/superErrors.ts(31,36): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+tests/cases/compiler/superErrors.ts(22,13): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/compiler/superErrors.ts(27,27): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/compiler/superErrors.ts(31,36): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
 tests/cases/compiler/superErrors.ts(31,41): error TS1034: 'super' must be followed by an argument list or member access.
-tests/cases/compiler/superErrors.ts(39,27): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
-tests/cases/compiler/superErrors.ts(43,36): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+tests/cases/compiler/superErrors.ts(39,27): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/compiler/superErrors.ts(43,36): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
 tests/cases/compiler/superErrors.ts(43,41): error TS1034: 'super' must be followed by an argument list or member access.
 tests/cases/compiler/superErrors.ts(47,22): error TS1034: 'super' must be followed by an argument list or member access.
 tests/cases/compiler/superErrors.ts(48,28): error TS1034: 'super' must be followed by an argument list or member access.
@@ -21,17 +21,17 @@ tests/cases/compiler/superErrors.ts(49,40): error TS1034: 'super' must be follow
         // super in a non class context
         var x = super;
                 ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
                      ~
 !!! error TS1034: 'super' must be followed by an argument list or member access.
         var y = () => super;
                       ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
                            ~
 !!! error TS1034: 'super' must be followed by an argument list or member access.
         var z = () => () => () => super;
                                   ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
                                        ~
 !!! error TS1034: 'super' must be followed by an argument list or member access.
     }
@@ -52,20 +52,20 @@ tests/cases/compiler/superErrors.ts(49,40): error TS1034: 'super' must be follow
             function inner() {
                 super.sayHello();
                 ~~~~~
-!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
             }
     
             // super call in a lambda in an inner function in a constructor 
             function inner2() {
                 var x = () => super.sayHello();
                               ~~~~~
-!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
             }
     
             // super call in a lambda in a function expression in a constructor 
             (function() { return () => super; })();
                                        ~~~~~
-!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
                                             ~
 !!! error TS1034: 'super' must be followed by an argument list or member access.
         }
@@ -77,13 +77,13 @@ tests/cases/compiler/superErrors.ts(49,40): error TS1034: 'super' must be follow
             function inner() {
                 var x = () => super.sayHello();
                               ~~~~~
-!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
             }
     
             // super call in a lambda in a function expression in a constructor 
             (function() { return () => super; })();
                                        ~~~~~
-!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
                                             ~
 !!! error TS1034: 'super' must be followed by an argument list or member access.
         }

tests/baselines/reference/superInObjectLiterals_ES5.errors.txt

@@ -0,0 +1,95 @@
+tests/cases/compiler/superInObjectLiterals_ES5.ts(7,9): error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
+tests/cases/compiler/superInObjectLiterals_ES5.ts(10,9): error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
+tests/cases/compiler/superInObjectLiterals_ES5.ts(14,9): error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
+tests/cases/compiler/superInObjectLiterals_ES5.ts(17,9): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/compiler/superInObjectLiterals_ES5.ts(20,9): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/compiler/superInObjectLiterals_ES5.ts(23,9): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/compiler/superInObjectLiterals_ES5.ts(39,17): error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
+tests/cases/compiler/superInObjectLiterals_ES5.ts(42,17): error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
+tests/cases/compiler/superInObjectLiterals_ES5.ts(46,17): error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
+tests/cases/compiler/superInObjectLiterals_ES5.ts(49,17): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/compiler/superInObjectLiterals_ES5.ts(52,17): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+
+
+==== tests/cases/compiler/superInObjectLiterals_ES5.ts (11 errors) ====
+    var obj = {
+        __proto__: {
+            method() {
+            }
+        },
+        method() {
+            super.method();
+            ~~~~~
+!!! error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
+        },
+        get prop() {
+            super.method();
+            ~~~~~
+!!! error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
+            return 10;
+        },
+        set prop(value) {
+            super.method();
+            ~~~~~
+!!! error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
+        },
+        p1: function () {
+            super.method();
+            ~~~~~
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+        },
+        p2: function f() {
+            super.method();
+            ~~~~~
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+        },
+        p3: () => {
+            super.method();
+            ~~~~~
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+        }
+    };
+    
+    class A {
+        method() { }
+    }
+    
+    class B extends A {
+        f() {
+            var obj = {
+                __proto__: {
+                    method() {
+                    }
+                },
+                method() {
+                    super.method();
+                    ~~~~~
+!!! error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
+                },
+                get prop() {
+                    super.method();
+                    ~~~~~
+!!! error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
+                    return 10;
+                },
+                set prop(value) {
+                    super.method();
+                    ~~~~~
+!!! error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
+                },
+                p1: function () {
+                    super.method();
+                    ~~~~~
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+                },
+                p2: function f() {
+                    super.method();
+                    ~~~~~
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+                },
+                p3: () => {
+                    super.method();
+                }
+            };
+        }
+    }

tests/baselines/reference/superInObjectLiterals_ES5.js

@@ -0,0 +1,133 @@
+//// [superInObjectLiterals_ES5.ts]
+var obj = {
+    __proto__: {
+        method() {
+        }
+    },
+    method() {
+        super.method();
+    },
+    get prop() {
+        super.method();
+        return 10;
+    },
+    set prop(value) {
+        super.method();
+    },
+    p1: function () {
+        super.method();
+    },
+    p2: function f() {
+        super.method();
+    },
+    p3: () => {
+        super.method();
+    }
+};
+
+class A {
+    method() { }
+}
+
+class B extends A {
+    f() {
+        var obj = {
+            __proto__: {
+                method() {
+                }
+            },
+            method() {
+                super.method();
+            },
+            get prop() {
+                super.method();
+                return 10;
+            },
+            set prop(value) {
+                super.method();
+            },
+            p1: function () {
+                super.method();
+            },
+            p2: function f() {
+                super.method();
+            },
+            p3: () => {
+                super.method();
+            }
+        };
+    }
+}
+
+//// [superInObjectLiterals_ES5.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var obj = {
+    __proto__: {
+        method: function () {
+        }
+    },
+    method: function () {
+        _super.prototype.method.call(this);
+    },
+    get prop() {
+        _super.prototype.method.call(this);
+        return 10;
+    },
+    set prop(value) {
+        _super.prototype.method.call(this);
+    },
+    p1: function () {
+        _super.method.call(this);
+    },
+    p2: function f() {
+        _super.method.call(this);
+    },
+    p3: function () {
+        _super.method.call(this);
+    }
+};
+var A = (function () {
+    function A() {
+    }
+    A.prototype.method = function () { };
+    return A;
+}());
+var B = (function (_super) {
+    __extends(B, _super);
+    function B() {
+        _super.apply(this, arguments);
+    }
+    B.prototype.f = function () {
+        var _this = this;
+        var obj = {
+            __proto__: {
+                method: function () {
+                }
+            },
+            method: function () {
+                _super.prototype.method.call(this);
+            },
+            get prop() {
+                _super.prototype.method.call(this);
+                return 10;
+            },
+            set prop(value) {
+                _super.prototype.method.call(this);
+            },
+            p1: function () {
+                _super.method.call(this);
+            },
+            p2: function f() {
+                _super.method.call(this);
+            },
+            p3: function () {
+                _super.prototype.method.call(_this);
+            }
+        };
+    };
+    return B;
+}(A));

tests/baselines/reference/superInObjectLiterals_ES6.errors.txt

@@ -0,0 +1,77 @@
+tests/cases/compiler/superInObjectLiterals_ES6.ts(17,9): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/compiler/superInObjectLiterals_ES6.ts(20,9): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/compiler/superInObjectLiterals_ES6.ts(23,9): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/compiler/superInObjectLiterals_ES6.ts(49,17): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+tests/cases/compiler/superInObjectLiterals_ES6.ts(52,17): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+
+
+==== tests/cases/compiler/superInObjectLiterals_ES6.ts (5 errors) ====
+    var obj = {
+        __proto__: {
+            method() {
+            }
+        },
+        method() {
+            super.method();
+        },
+        get prop() {
+            super.method();
+            return 10;
+        },
+        set prop(value) {
+            super.method();
+        },
+        p1: function () {
+            super.method();
+            ~~~~~
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+        },
+        p2: function f() {
+            super.method();
+            ~~~~~
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+        },
+        p3: () => {
+            super.method();
+            ~~~~~
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+        }
+    };
+    
+    class A {
+        method() { }
+    }
+    
+    class B extends A {
+        f() {
+            var obj = {
+                __proto__: {
+                    method() {
+                    }
+                },
+                method() {
+                    super.method();
+                },
+                get prop() {
+                    super.method();
+                    return 10;
+                },
+                set prop(value) {
+                    super.method();
+                },
+                p1: function () {
+                    super.method();
+                    ~~~~~
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+                },
+                p2: function f() {
+                    super.method();
+                    ~~~~~
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
+                },
+                p3: () => {
+                    super.method();
+                }
+            };
+        }
+    }

tests/baselines/reference/superInObjectLiterals_ES6.js

@@ -0,0 +1,119 @@
+//// [superInObjectLiterals_ES6.ts]
+var obj = {
+    __proto__: {
+        method() {
+        }
+    },
+    method() {
+        super.method();
+    },
+    get prop() {
+        super.method();
+        return 10;
+    },
+    set prop(value) {
+        super.method();
+    },
+    p1: function () {
+        super.method();
+    },
+    p2: function f() {
+        super.method();
+    },
+    p3: () => {
+        super.method();
+    }
+};
+
+class A {
+    method() { }
+}
+
+class B extends A {
+    f() {
+        var obj = {
+            __proto__: {
+                method() {
+                }
+            },
+            method() {
+                super.method();
+            },
+            get prop() {
+                super.method();
+                return 10;
+            },
+            set prop(value) {
+                super.method();
+            },
+            p1: function () {
+                super.method();
+            },
+            p2: function f() {
+                super.method();
+            },
+            p3: () => {
+                super.method();
+            }
+        };
+    }
+}
+
+//// [superInObjectLiterals_ES6.js]
+var obj = {
+    __proto__: {
+        method() {
+        }
+    },
+    method() {
+        super.method();
+    },
+    get prop() {
+        super.method();
+        return 10;
+    },
+    set prop(value) {
+        super.method();
+    },
+    p1: function () {
+        super.method();
+    },
+    p2: function f() {
+        super.method();
+    },
+    p3: () => {
+        super.method();
+    }
+};
+class A {
+    method() { }
+}
+class B extends A {
+    f() {
+        var obj = {
+            __proto__: {
+                method() {
+                }
+            },
+            method() {
+                super.method();
+            },
+            get prop() {
+                super.method();
+                return 10;
+            },
+            set prop(value) {
+                super.method();
+            },
+            p1: function () {
+                super.method();
+            },
+            p2: function f() {
+                super.method();
+            },
+            p3: () => {
+                super.method();
+            }
+        };
+    }
+}

tests/baselines/reference/superPropertyAccessInComputedPropertiesOfNestedType_ES5.js

@@ -0,0 +1,46 @@
+//// [superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts]
+class A {
+    foo() { return 1; }
+}
+
+class B extends A {
+    foo() { return 2; }
+    bar() {
+        return class {
+            [super.foo()]() {
+                return 100;
+            }
+        }
+    }
+}
+
+//// [superPropertyAccessInComputedPropertiesOfNestedType_ES5.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var A = (function () {
+    function A() {
+    }
+    A.prototype.foo = function () { return 1; };
+    return A;
+}());
+var B = (function (_super) {
+    __extends(B, _super);
+    function B() {
+        _super.apply(this, arguments);
+    }
+    B.prototype.foo = function () { return 2; };
+    B.prototype.bar = function () {
+        return (function () {
+            function class_1() {
+            }
+            class_1.prototype[_super.prototype.foo.call(this)] = function () {
+                return 100;
+            };
+            return class_1;
+        }());
+    };
+    return B;
+}(A));

tests/baselines/reference/superPropertyAccessInComputedPropertiesOfNestedType_ES5.symbols

@@ -0,0 +1,29 @@
+=== tests/cases/compiler/superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts ===
+class A {
+>A : Symbol(A, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts, 0, 0))
+
+    foo() { return 1; }
+>foo : Symbol(foo, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts, 0, 9))
+}
+
+class B extends A {
+>B : Symbol(B, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts, 2, 1))
+>A : Symbol(A, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts, 0, 0))
+
+    foo() { return 2; }
+>foo : Symbol(foo, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts, 4, 19))
+
+    bar() {
+>bar : Symbol(bar, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts, 5, 23))
+
+        return class {
+            [super.foo()]() {
+>super.foo : Symbol(A.foo, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts, 0, 9))
+>super : Symbol(A, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts, 0, 0))
+>foo : Symbol(A.foo, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts, 0, 9))
+
+                return 100;
+            }
+        }
+    }
+}

tests/baselines/reference/superPropertyAccessInComputedPropertiesOfNestedType_ES5.types

@@ -0,0 +1,35 @@
+=== tests/cases/compiler/superPropertyAccessInComputedPropertiesOfNestedType_ES5.ts ===
+class A {
+>A : A
+
+    foo() { return 1; }
+>foo : () => number
+>1 : number
+}
+
+class B extends A {
+>B : B
+>A : A
+
+    foo() { return 2; }
+>foo : () => number
+>2 : number
+
+    bar() {
+>bar : () => typeof (Anonymous class)
+
+        return class {
+>class {            [super.foo()]() {                return 100;            }        } : typeof (Anonymous class)
+
+            [super.foo()]() {
+>super.foo() : number
+>super.foo : () => number
+>super : A
+>foo : () => number
+
+                return 100;
+>100 : number
+            }
+        }
+    }
+}

tests/baselines/reference/superPropertyAccessInComputedPropertiesOfNestedType_ES6.js

@@ -0,0 +1,31 @@
+//// [superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts]
+class A {
+    foo() { return 1; }
+}
+
+class B extends A {
+    foo() { return 2; }
+    bar() {
+        return class {
+            [super.foo()]() {
+                return 100;
+            }
+        }
+    }
+}
+
+//// [superPropertyAccessInComputedPropertiesOfNestedType_ES6.js]
+class A {
+    foo() { return 1; }
+}
+class B extends A {
+    foo() { return 2; }
+    bar() {
+        return class {
+            [super.foo()]() {
+                return 100;
+            }
+        }
+        ;
+    }
+}

tests/baselines/reference/superPropertyAccessInComputedPropertiesOfNestedType_ES6.symbols

@@ -0,0 +1,29 @@
+=== tests/cases/compiler/superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts ===
+class A {
+>A : Symbol(A, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts, 0, 0))
+
+    foo() { return 1; }
+>foo : Symbol(foo, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts, 0, 9))
+}
+
+class B extends A {
+>B : Symbol(B, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts, 2, 1))
+>A : Symbol(A, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts, 0, 0))
+
+    foo() { return 2; }
+>foo : Symbol(foo, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts, 4, 19))
+
+    bar() {
+>bar : Symbol(bar, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts, 5, 23))
+
+        return class {
+            [super.foo()]() {
+>super.foo : Symbol(A.foo, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts, 0, 9))
+>super : Symbol(A, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts, 0, 0))
+>foo : Symbol(A.foo, Decl(superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts, 0, 9))
+
+                return 100;
+            }
+        }
+    }
+}

tests/baselines/reference/superPropertyAccessInComputedPropertiesOfNestedType_ES6.types

@@ -0,0 +1,35 @@
+=== tests/cases/compiler/superPropertyAccessInComputedPropertiesOfNestedType_ES6.ts ===
+class A {
+>A : A
+
+    foo() { return 1; }
+>foo : () => number
+>1 : number
+}
+
+class B extends A {
+>B : B
+>A : A
+
+    foo() { return 2; }
+>foo : () => number
+>2 : number
+
+    bar() {
+>bar : () => typeof (Anonymous class)
+
+        return class {
+>class {            [super.foo()]() {                return 100;            }        } : typeof (Anonymous class)
+
+            [super.foo()]() {
+>super.foo() : number
+>super.foo : () => number
+>super : A
+>foo : () => number
+
+                return 100;
+>100 : number
+            }
+        }
+    }
+}

tests/baselines/reference/super_inside-object-literal-getters-and-setters.errors.txt

@@ -1,10 +1,10 @@
 tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(4,13): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
-tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(5,20): error TS2335: 'super' can only be referenced in a derived class.
+tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(5,20): error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
 tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(7,13): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
-tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(8,13): error TS2335: 'super' can only be referenced in a derived class.
-tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(11,20): error TS2335: 'super' can only be referenced in a derived class.
+tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(8,13): error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
+tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(11,20): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
 tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(20,17): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
-tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(21,24): error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(21,24): error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
 
 
 ==== tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts (7 errors) ====
@@ -16,19 +16,19 @@ tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(21,24):
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
                 return super._foo;
                        ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
             },
             set foo(value: string) {
                 ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
                 super._foo = value;
                 ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
             },
             test: function () {
                 return super._foo;
                        ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
+!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions.
             }
         }
     }
@@ -42,7 +42,7 @@ tests/cases/compiler/super_inside-object-literal-getters-and-setters.ts(21,24):
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
                     return super.test();
                            ~~~~~
-!!! error TS2338: 'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.
+!!! error TS2659: 'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher.
                 }
             };
         }

tests/baselines/reference/super_inside-object-literal-getters-and-setters.js

@@ -38,10 +38,10 @@ var ObjectLiteral;
     var ThisInObjectLiteral = {
         _foo: '1',
         get foo() {
-            return _super._foo;
+            return _super.prototype._foo;
         },
         set foo(value) {
-            _super._foo = value;
+            _super.prototype._foo = value;
         },
         test: function () {
             return _super._foo;
@@ -62,7 +62,7 @@ var SuperObjectTest = (function (_super) {
     SuperObjectTest.prototype.testing = function () {
         var test = {
             get F() {
-                return _super.test.call(this);
+                return _super.prototype.test.call(this);
             }
         };
     };

tests/baselines/reference/tsxAttributeResolution11.errors.txt

@@ -0,0 +1,33 @@
+tests/cases/conformance/jsx/file.tsx(11,22): error TS2339: Property 'bar' does not exist on type 'IntrinsicAttributes & { ref?: string; }'.
+
+
+==== tests/cases/conformance/jsx/react.d.ts (0 errors) ====
+    
+    declare module JSX {
+    	interface Element { }
+    	interface IntrinsicElements {
+    	}
+    	interface ElementAttributesProperty {
+    		props;
+    	}
+    	interface IntrinsicAttributes {
+    		ref?: string;
+    	}
+    }
+    
+==== tests/cases/conformance/jsx/file.tsx (1 errors) ====
+    class MyComponent {  
+      render() {
+      }
+    
+      props: {
+    	  ref?: string;
+      }
+    }
+    
+    // Should be an OK
+    var x = <MyComponent bar='world' />;
+                         ~~~
+!!! error TS2339: Property 'bar' does not exist on type 'IntrinsicAttributes & { ref?: string; }'.
+    
+    

tests/baselines/reference/tsxAttributeResolution11.js

@@ -0,0 +1,41 @@
+//// [tests/cases/conformance/jsx/tsxAttributeResolution11.tsx] ////
+
+//// [react.d.ts]
+
+declare module JSX {
+	interface Element { }
+	interface IntrinsicElements {
+	}
+	interface ElementAttributesProperty {
+		props;
+	}
+	interface IntrinsicAttributes {
+		ref?: string;
+	}
+}
+
+//// [file.tsx]
+class MyComponent {  
+  render() {
+  }
+
+  props: {
+	  ref?: string;
+  }
+}
+
+// Should be an OK
+var x = <MyComponent bar='world' />;
+
+
+
+//// [file.jsx]
+var MyComponent = (function () {
+    function MyComponent() {
+    }
+    MyComponent.prototype.render = function () {
+    };
+    return MyComponent;
+}());
+// Should be an OK
+var x = <MyComponent bar='world'/>;

tests/cases/compiler/DeclarationErrorsNoEmitOnError.ts

@@ -0,0 +1,8 @@
+// @module: commonjs
+// @declaration: true
+// @noEmitOnError: true
+
+type T = { x : number }
+export interface I {
+    f: T;   
+}

tests/cases/compiler/arrayLiteralComments.ts

@@ -0,0 +1,14 @@
+var testArrayWithFunc = [
+    // Function comment
+    function() {
+        let x = 1;
+    },
+    // String comment
+    '1',
+    // Numeric comment
+    2,
+    // Object comment
+    { a: 1 },
+    // Array comment
+    [1, 2, 3]
+]