Merge branch 'master' into release-1.5

Jakefile

@@ -144,7 +144,8 @@ var harnessSources = [
     "services/colorization.ts",
     "services/documentRegistry.ts",
     "services/preProcessFile.ts",
-    "services/patternMatcher.ts"
+    "services/patternMatcher.ts",
+    "versionCache.ts"
 ].map(function (f) {
     return path.join(unittestsDirectory, f);
 })).concat([

src/compiler/binder.ts

@@ -388,23 +388,28 @@ module ts {
             bindChildren(node, /*symbolKind:*/ 0, /*isBlockScopeContainer:*/ true);
         }
 
-        function bindBlockScopedVariableDeclaration(node: Declaration) {
+        function bindBlockScopedDeclaration(node: Declaration, symbolKind: SymbolFlags, symbolExcludes: SymbolFlags) {
             switch (blockScopeContainer.kind) {
                 case SyntaxKind.ModuleDeclaration:
-                    declareModuleMember(node, SymbolFlags.BlockScopedVariable, SymbolFlags.BlockScopedVariableExcludes);
+                    declareModuleMember(node, symbolKind, symbolExcludes);
                     break;
                 case SyntaxKind.SourceFile:
                     if (isExternalModule(<SourceFile>container)) {
-                        declareModuleMember(node, SymbolFlags.BlockScopedVariable, SymbolFlags.BlockScopedVariableExcludes);
+                        declareModuleMember(node, symbolKind, symbolExcludes);
                         break;
                     }
+                    // fall through.
                 default:
                     if (!blockScopeContainer.locals) {
                         blockScopeContainer.locals = {};
                     }
-                    declareSymbol(blockScopeContainer.locals, undefined, node, SymbolFlags.BlockScopedVariable, SymbolFlags.BlockScopedVariableExcludes);
+                    declareSymbol(blockScopeContainer.locals, undefined, node, symbolKind, symbolExcludes);
             }
-            bindChildren(node, SymbolFlags.BlockScopedVariable, /*isBlockScopeContainer*/ false);
+            bindChildren(node, symbolKind, /*isBlockScopeContainer*/ false);
+        }
+
+        function bindBlockScopedVariableDeclaration(node: Declaration) {
+            bindBlockScopedDeclaration(node, SymbolFlags.BlockScopedVariable, SymbolFlags.BlockScopedVariableExcludes);
         }
 
         function getDestructuringParameterName(node: Declaration) {
@@ -493,7 +498,7 @@ module ts {
                     bindCatchVariableDeclaration(<CatchClause>node);
                     break;
                 case SyntaxKind.ClassDeclaration:
-                    bindDeclaration(<Declaration>node, SymbolFlags.Class, SymbolFlags.ClassExcludes, /*isBlockScopeContainer*/ false);
+                    bindBlockScopedDeclaration(<Declaration>node, SymbolFlags.Class, SymbolFlags.ClassExcludes);
                     break;
                 case SyntaxKind.InterfaceDeclaration:
                     bindDeclaration(<Declaration>node, SymbolFlags.Interface, SymbolFlags.InterfaceExcludes, /*isBlockScopeContainer*/ false);

src/compiler/checker.ts

@@ -74,7 +74,7 @@ module ts {
             isImplementationOfOverload,
             getAliasedSymbol: resolveAlias,
             getEmitResolver,
-            getExportsOfExternalModule,
+            getExportsOfModule: getExportsOfModuleAsArray,
         };
 
         let unknownSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "unknown");
@@ -126,6 +126,7 @@ module ts {
         let stringLiteralTypes: Map<StringLiteralType> = {};
         let emitExtends = false;
         let emitDecorate = false;
+        let emitParam = false;
 
         let mergedSymbols: Symbol[] = [];
         let symbolLinks: SymbolLinks[] = [];
@@ -898,6 +899,10 @@ module ts {
             return moduleSymbol.exports["export="];
         }
 
+        function getExportsOfModuleAsArray(moduleSymbol: Symbol): Symbol[] {
+            return symbolsToArray(getExportsOfModule(moduleSymbol));
+        }
+
         function getExportsOfSymbol(symbol: Symbol): SymbolTable {
             return symbol.flags & SymbolFlags.Module ? getExportsOfModule(symbol) : symbol.exports || emptySymbols;
         }
@@ -924,7 +929,7 @@ module ts {
             // The ES6 spec permits export * declarations in a module to circularly reference the module itself. For example,
             // module 'a' can 'export * from "b"' and 'b' can 'export * from "a"' without error.
             function visit(symbol: Symbol) {
-                if (symbol.flags & SymbolFlags.HasExports && !contains(visitedSymbols, symbol)) {
+                if (symbol && symbol.flags & SymbolFlags.HasExports && !contains(visitedSymbols, symbol)) {
                     visitedSymbols.push(symbol);
                     if (symbol !== moduleSymbol) {
                         if (!result) {
@@ -2073,15 +2078,20 @@ module ts {
                 }
             }
             else {
-                // For an array binding element the specified or inferred type of the parent must be an array-like type
-                if (!isArrayLikeType(parentType)) {
-                    error(pattern, Diagnostics.Type_0_is_not_an_array_type, typeToString(parentType));
-                    return unknownType;
-                }
+                // This elementType will be used if the specific property corresponding to this index is not
+                // present (aka the tuple element property). This call also checks that the parentType is in
+                // fact an iterable or array (depending on target language).
+                let elementType = checkIteratedTypeOrElementType(parentType, pattern, /*allowStringInput*/ false);
                 if (!declaration.dotDotDotToken) {
+                    if (elementType.flags & TypeFlags.Any) {
+                        return elementType;
+                    }
+
                     // Use specific property type when parent is a tuple or numeric index type when parent is an array
                     let propName = "" + indexOf(pattern.elements, declaration);
-                    type = isTupleLikeType(parentType) ? getTypeOfPropertyOfType(parentType, propName) : getIndexTypeOfType(parentType, IndexKind.Number);
+                    type = isTupleLikeType(parentType)
+                        ? getTypeOfPropertyOfType(parentType, propName)
+                        : elementType;
                     if (!type) {
                         if (isTupleType(parentType)) {
                             error(declaration, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(parentType), (<TupleType>parentType).elementTypes.length, pattern.elements.length);
@@ -2094,7 +2104,7 @@ module ts {
                 }
                 else {
                     // Rest element has an array type with the same element type as the parent type
-                    type = createArrayType(getIndexTypeOfType(parentType, IndexKind.Number));
+                    type = createArrayType(elementType);
                 }
             }
             return type;
@@ -2183,7 +2193,34 @@ module ts {
                     hasSpreadElement = true;
                 }
             });
-            return !elementTypes.length ? anyArrayType : hasSpreadElement ? createArrayType(getUnionType(elementTypes)) : createTupleType(elementTypes);
+            if (!elementTypes.length) {
+                return languageVersion >= ScriptTarget.ES6 ? createIterableType(anyType) : anyArrayType;
+            }
+            else if (hasSpreadElement) {
+                let unionOfElements = getUnionType(elementTypes);
+                if (languageVersion >= ScriptTarget.ES6) {
+                    // If the user has something like:
+                    //
+                    //     function fun(...[a, ...b]) { }
+                    //
+                    // Normally, in ES6, the implied type of an array binding pattern with a rest element is
+                    // an iterable. However, there is a requirement in our type system that all rest
+                    // parameters be array types. To satisfy this, we have an exception to the rule that
+                    // says the type of an array binding pattern with a rest element is an array type
+                    // if it is *itself* in a rest parameter. It will still be compatible with a spreaded
+                    // iterable argument, but within the function it will be an array.
+                    let parent = pattern.parent;
+                    let isRestParameter = parent.kind === SyntaxKind.Parameter &&
+                        pattern === (<ParameterDeclaration>parent).name &&
+                        (<ParameterDeclaration>parent).dotDotDotToken !== undefined;
+                    return isRestParameter ? createArrayType(unionOfElements) : createIterableType(unionOfElements);
+                }
+
+                return createArrayType(unionOfElements);
+            }
+
+            // If the pattern has at least one element, and no rest element, then it should imply a tuple type.
+            return createTupleType(elementTypes);
         }
 
         // Return the type implied by a binding pattern. This is the type implied purely by the binding pattern itself
@@ -2996,6 +3033,16 @@ module ts {
             return getSignaturesOfObjectOrUnionType(getApparentType(type), kind);
         }
 
+        function typeHasCallOrConstructSignatures(type: Type): boolean {
+            let apparentType = getApparentType(type);
+            if (apparentType.flags & (TypeFlags.ObjectType | TypeFlags.Union)) {
+                let resolved = resolveObjectOrUnionTypeMembers(<ObjectType>type);
+                return resolved.callSignatures.length > 0
+                    || resolved.constructSignatures.length > 0;
+            }
+            return false;
+        }
+
         function getIndexTypeOfObjectOrUnionType(type: Type, kind: IndexKind): Type {
             if (type.flags & (TypeFlags.ObjectType | TypeFlags.Union)) {
                 let resolved = resolveObjectOrUnionTypeMembers(<ObjectType>type);
@@ -3032,17 +3079,6 @@ module ts {
             return result;
         }
 
-        function getExportsOfExternalModule(node: ImportDeclaration): Symbol[] {
-            if (!node.moduleSpecifier) {
-                return emptyArray;
-            }
-            let module = resolveExternalModuleName(node, node.moduleSpecifier);
-            if (!module) {
-                return emptyArray;
-            }
-            return symbolsToArray(getExportsOfModule(module));
-        }
-
         function getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature {
             let links = getNodeLinks(declaration);
             if (!links.resolvedSignature) {
@@ -3457,6 +3493,10 @@ module ts {
             return globalESSymbolConstructorSymbol || (globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol"));
         }
 
+        function createIterableType(elementType: Type): Type {
+            return globalIterableType !== emptyObjectType ? createTypeReference(<GenericType>globalIterableType, [elementType]) : emptyObjectType;
+        }
+
         function createArrayType(elementType: Type): Type {
             // globalArrayType will be undefined if we get here during creation of the Array type. This for example happens if
             // user code augments the Array type with call or construct signatures that have an array type as the return type.
@@ -5596,7 +5636,7 @@ module ts {
                 }
             }
 
-            if (container.kind === SyntaxKind.ComputedPropertyName) {
+            if (container && container.kind === SyntaxKind.ComputedPropertyName) {
                 error(node, Diagnostics.super_cannot_be_referenced_in_a_computed_property_name);
             }
             else if (isCallExpression) {
@@ -5964,12 +6004,14 @@ module ts {
         }
 
         function checkSpreadElementExpression(node: SpreadElementExpression, contextualMapper?: TypeMapper): Type {
-            let type = checkExpressionCached(node.expression, contextualMapper);
-            if (!isArrayLikeType(type)) {
-                error(node.expression, Diagnostics.Type_0_is_not_an_array_type, typeToString(type));
-                return unknownType;
-            }
-            return type;
+            // It is usually not safe to call checkExpressionCached if we can be contextually typing.
+            // You can tell that we are contextually typing because of the contextualMapper parameter.
+            // While it is true that a spread element can have a contextual type, it does not do anything
+            // with this type. It is neither affected by it, nor does it propagate it to its operand.
+            // So the fact that contextualMapper is passed is not important, because the operand of a spread
+            // element is not contextually typed.
+            let arrayOrIterableType = checkExpressionCached(node.expression, contextualMapper);
+            return checkIteratedTypeOrElementType(arrayOrIterableType, node.expression, /*allowStringInput*/ false);
         }
 
         function checkArrayLiteral(node: ArrayLiteralExpression, contextualMapper?: TypeMapper): Type {
@@ -5977,18 +6019,13 @@ module ts {
             if (!elements.length) {
                 return createArrayType(undefinedType);
             }
-            let hasSpreadElement: boolean = false;
+            let hasSpreadElement = false;
             let elementTypes: Type[] = [];
-            forEach(elements, e => {
+            for (let e of elements) {
                 let type = checkExpression(e, contextualMapper);
-                if (e.kind === SyntaxKind.SpreadElementExpression) {
-                    elementTypes.push(getIndexTypeOfType(type, IndexKind.Number) || anyType);
-                    hasSpreadElement = true;
-                }
-                else {
-                    elementTypes.push(type);
-                }
-            });
+                elementTypes.push(type);
+                hasSpreadElement = hasSpreadElement || e.kind === SyntaxKind.SpreadElementExpression;
+            }
             if (!hasSpreadElement) {
                 let contextualType = getContextualType(node);
                 if (contextualType && contextualTypeIsTupleLikeType(contextualType) || isAssignmentTarget(node)) {
@@ -6611,7 +6648,7 @@ module ts {
             for (let i = 0; i < args.length; i++) {
                 let arg = args[i];
                 if (arg.kind !== SyntaxKind.OmittedExpression) {
-                    let paramType = getTypeAtPosition(signature, arg.kind === SyntaxKind.SpreadElementExpression ? -1 : i);
+                    let paramType = getTypeAtPosition(signature, i);
                     let argType: Type;
                     if (i === 0 && args[i].parent.kind === SyntaxKind.TaggedTemplateExpression) {
                         argType = globalTemplateStringsArrayType;
@@ -6634,7 +6671,7 @@ module ts {
                     // No need to check for omitted args and template expressions, their exlusion value is always undefined
                     if (excludeArgument[i] === false) {
                         let arg = args[i];
-                        let paramType = getTypeAtPosition(signature, arg.kind === SyntaxKind.SpreadElementExpression ? -1 : i);
+                        let paramType = getTypeAtPosition(signature, i);
                         inferTypes(context, checkExpressionWithContextualType(arg, paramType, inferenceMapper), paramType);
                     }
                 }
@@ -6667,7 +6704,7 @@ module ts {
                 let arg = args[i];
                 if (arg.kind !== SyntaxKind.OmittedExpression) {
                     // Check spread elements against rest type (from arity check we know spread argument corresponds to a rest parameter)
-                    let paramType = getTypeAtPosition(signature, arg.kind === SyntaxKind.SpreadElementExpression ? -1 : i);
+                    let paramType = getTypeAtPosition(signature, i);
                     // A tagged template expression provides a special first argument, and string literals get string literal types
                     // unless we're reporting errors
                     let argType = i === 0 && node.kind === SyntaxKind.TaggedTemplateExpression ? globalTemplateStringsArrayType :
@@ -7141,14 +7178,9 @@ module ts {
         }
 
         function getTypeAtPosition(signature: Signature, pos: number): Type {
-            if (pos >= 0) {
-                return signature.hasRestParameter ?
-                    pos < signature.parameters.length - 1 ? getTypeOfSymbol(signature.parameters[pos]) : getRestTypeOfSignature(signature) :
-                    pos < signature.parameters.length ? getTypeOfSymbol(signature.parameters[pos]) : anyType;
-            }
             return signature.hasRestParameter ?
-                getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]) :
-                anyArrayType;
+                pos < signature.parameters.length - 1 ? getTypeOfSymbol(signature.parameters[pos]) : getRestTypeOfSignature(signature) :
+                pos < signature.parameters.length ? getTypeOfSymbol(signature.parameters[pos]) : anyType;
         }
 
         function assignContextualParameterTypes(signature: Signature, context: Signature, mapper: TypeMapper) {
@@ -7584,11 +7616,10 @@ module ts {
         }
 
         function checkArrayLiteralAssignment(node: ArrayLiteralExpression, sourceType: Type, contextualMapper?: TypeMapper): Type {
-            // TODOO(andersh): Allow iterable source type in ES6
-            if (!isArrayLikeType(sourceType)) {
-                error(node, Diagnostics.Type_0_is_not_an_array_type, typeToString(sourceType));
-                return sourceType;
-            }
+            // This elementType will be used if the specific property corresponding to this index is not
+            // present (aka the tuple element property). This call also checks that the parentType is in
+            // fact an iterable or array (depending on target language).
+            let elementType = checkIteratedTypeOrElementType(sourceType, node, /*allowStringInput*/ false);
             let elements = node.elements;
             for (let i = 0; i < elements.length; i++) {
                 let e = elements[i];
@@ -7596,8 +7627,9 @@ module ts {
                     if (e.kind !== SyntaxKind.SpreadElementExpression) {
                         let propName = "" + i;
                         let type = sourceType.flags & TypeFlags.Any ? sourceType :
-                            isTupleLikeType(sourceType) ? getTypeOfPropertyOfType(sourceType, propName) :
-                                getIndexTypeOfType(sourceType, IndexKind.Number);
+                            isTupleLikeType(sourceType)
+                                ? getTypeOfPropertyOfType(sourceType, propName)
+                                : elementType;
                         if (type) {
                             checkDestructuringAssignment(e, type, contextualMapper);
                         }
@@ -7612,7 +7644,7 @@ module ts {
                     }
                     else {
                         if (i === elements.length - 1) {
-                            checkReferenceAssignment((<SpreadElementExpression>e).expression, sourceType, contextualMapper);
+                            checkReferenceAssignment((<SpreadElementExpression>e).expression, createArrayType(elementType), contextualMapper);
                         }
                         else {
                             error(e, Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern);
@@ -8734,24 +8766,92 @@ module ts {
             }
         }
 
+        /** Checks a type reference node as an expression. */
+        function checkTypeNodeAsExpression(node: TypeNode | LiteralExpression) {
+            // When we are emitting type metadata for decorators, we need to try to check the type
+            // as if it were an expression so that we can emit the type in a value position when we 
+            // serialize the type metadata.
+            if (node && node.kind === SyntaxKind.TypeReference) {
+                let type = getTypeFromTypeNodeOrHeritageClauseElement(node);
+                let shouldCheckIfUnknownType = type === unknownType && compilerOptions.separateCompilation;
+                if (!type || (!shouldCheckIfUnknownType && type.flags & (TypeFlags.Intrinsic | TypeFlags.NumberLike | TypeFlags.StringLike))) {
+                    return;
+                }
+                if (shouldCheckIfUnknownType || type.symbol.valueDeclaration) {
+                    checkExpressionOrQualifiedName((<TypeReferenceNode>node).typeName);
+                }
+            }
+        }
+
+        /**
+          * Checks the type annotation of an accessor declaration or property declaration as 
+          * an expression if it is a type reference to a type with a value declaration.
+          */
+        function checkTypeAnnotationAsExpression(node: AccessorDeclaration | PropertyDeclaration | ParameterDeclaration | MethodDeclaration) {
+            switch (node.kind) {
+                case SyntaxKind.PropertyDeclaration:
+                    checkTypeNodeAsExpression((<PropertyDeclaration>node).type);
+                    break;
+                case SyntaxKind.Parameter: checkTypeNodeAsExpression((<ParameterDeclaration>node).type);
+                    break;
+                case SyntaxKind.MethodDeclaration:
+                    checkTypeNodeAsExpression((<MethodDeclaration>node).type);
+                    break;
+                case SyntaxKind.GetAccessor:
+                    checkTypeNodeAsExpression((<AccessorDeclaration>node).type);
+                    break;
+                case SyntaxKind.SetAccessor:
+                    checkTypeNodeAsExpression(getSetAccessorTypeAnnotationNode(<AccessorDeclaration>node));
+                    break;
+            }
+        }
+        
+        /** Checks the type annotation of the parameters of a function/method or the constructor of a class as expressions */
+        function checkParameterTypeAnnotationsAsExpressions(node: FunctionLikeDeclaration) {
+            // ensure all type annotations with a value declaration are checked as an expression
+            for (let parameter of node.parameters) {
+                checkTypeAnnotationAsExpression(parameter);
+            }
+        }
+
         /** Check the decorators of a node */
         function checkDecorators(node: Node): void {
             if (!node.decorators) {
                 return;
-            }            
+            }
 
-            switch (node.kind) {
-                case SyntaxKind.ClassDeclaration:
-                case SyntaxKind.MethodDeclaration:
-                case SyntaxKind.GetAccessor:
-                case SyntaxKind.SetAccessor:
-                case SyntaxKind.PropertyDeclaration:
-                case SyntaxKind.Parameter:
-                    emitDecorate = true;
-                    break;
+            // skip this check for nodes that cannot have decorators. These should have already had an error reported by
+            // checkGrammarDecorators.
+            if (!nodeCanBeDecorated(node)) {
+                return;
+            }
 
-                default:
-                    return;
+            if (compilerOptions.emitDecoratorMetadata) {
+                // we only need to perform these checks if we are emitting serialized type metadata for the target of a decorator.
+                switch (node.kind) {
+                    case SyntaxKind.ClassDeclaration:
+                        var constructor = getFirstConstructorWithBody(<ClassDeclaration>node);
+                        if (constructor) {
+                            checkParameterTypeAnnotationsAsExpressions(constructor);
+                        }
+                        break;
+
+                    case SyntaxKind.MethodDeclaration:
+                        checkParameterTypeAnnotationsAsExpressions(<FunctionLikeDeclaration>node);
+                        // fall-through
+
+                    case SyntaxKind.SetAccessor:
+                    case SyntaxKind.GetAccessor:
+                    case SyntaxKind.PropertyDeclaration:
+                    case SyntaxKind.Parameter:
+                        checkTypeAnnotationAsExpression(<PropertyDeclaration | ParameterDeclaration>node);
+                        break;
+                }
+            }
+
+            emitDecorate = true;
+            if (node.kind === SyntaxKind.Parameter) {
+                emitParam = true;
             }
 
             forEach(node.decorators, checkDecorator);
@@ -9301,29 +9401,41 @@ module ts {
 
         function checkRightHandSideOfForOf(rhsExpression: Expression): Type {
             let expressionType = getTypeOfExpression(rhsExpression);
-            return languageVersion >= ScriptTarget.ES6
-                ? checkIteratedType(expressionType, rhsExpression)
-                : checkElementTypeOfArrayOrString(expressionType, rhsExpression);
+            return checkIteratedTypeOrElementType(expressionType, rhsExpression, /*allowStringInput*/ true);
+        }
+
+        function checkIteratedTypeOrElementType(inputType: Type, errorNode: Node, allowStringInput: boolean): Type {
+            if (languageVersion >= ScriptTarget.ES6) {
+                return checkIteratedType(inputType, errorNode) || anyType;
+            }
+
+            if (allowStringInput) {
+                return checkElementTypeOfArrayOrString(inputType, errorNode);
+            }
+            
+            if (isArrayLikeType(inputType)) {
+                return getIndexTypeOfType(inputType, IndexKind.Number);
+            }
+
+            error(errorNode, Diagnostics.Type_0_is_not_an_array_type, typeToString(inputType));
+            return unknownType;
         }
 
         /**
-         * When expressionForError is undefined, it means we should not report any errors.
+         * When errorNode is undefined, it means we should not report any errors.
          */
-        function checkIteratedType(iterable: Type, expressionForError: Expression): Type {
+        function checkIteratedType(iterable: Type, errorNode: Node): Type {
             Debug.assert(languageVersion >= ScriptTarget.ES6);
-            let iteratedType = getIteratedType(iterable, expressionForError);
+            let iteratedType = getIteratedType(iterable, errorNode);
             // Now even though we have extracted the iteratedType, we will have to validate that the type
             // passed in is actually an Iterable.
-            if (expressionForError && iteratedType) {
-                let completeIterableType = globalIterableType !== emptyObjectType
-                    ? createTypeReference(<GenericType>globalIterableType, [iteratedType])
-                    : emptyObjectType;
-                checkTypeAssignableTo(iterable, completeIterableType, expressionForError);
+            if (errorNode && iteratedType) {
+                checkTypeAssignableTo(iterable, createIterableType(iteratedType), errorNode);
             }
 
             return iteratedType;
 
-            function getIteratedType(iterable: Type, expressionForError: Expression) {
+            function getIteratedType(iterable: Type, errorNode: Node) {
                 // We want to treat type as an iterable, and get the type it is an iterable of. The iterable
                 // must have the following structure (annotated with the names of the variables below):
                 //
@@ -9354,6 +9466,12 @@ module ts {
                     return undefined;
                 }
 
+                // As an optimization, if the type is instantiated directly using the globalIterableType (Iterable<number>),
+                // then just grab its type argument.
+                if ((iterable.flags & TypeFlags.Reference) && (<GenericType>iterable).target === globalIterableType) {
+                    return (<GenericType>iterable).typeArguments[0];
+                }
+
                 let iteratorFunction = getTypeOfPropertyOfType(iterable, getPropertyNameForKnownSymbolName("iterator"));
                 if (iteratorFunction && allConstituentTypesHaveKind(iteratorFunction, TypeFlags.Any)) {
                     return undefined;
@@ -9361,8 +9479,8 @@ module ts {
 
                 let iteratorFunctionSignatures = iteratorFunction ? getSignaturesOfType(iteratorFunction, SignatureKind.Call) : emptyArray;
                 if (iteratorFunctionSignatures.length === 0) {
-                    if (expressionForError) {
-                        error(expressionForError, Diagnostics.The_right_hand_side_of_a_for_of_statement_must_have_a_Symbol_iterator_method_that_returns_an_iterator);
+                    if (errorNode) {
+                        error(errorNode, Diagnostics.Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator);
                     }
                     return undefined;
                 }
@@ -9379,8 +9497,8 @@ module ts {
 
                 let iteratorNextFunctionSignatures = iteratorNextFunction ? getSignaturesOfType(iteratorNextFunction, SignatureKind.Call) : emptyArray;
                 if (iteratorNextFunctionSignatures.length === 0) {
-                    if (expressionForError) {
-                        error(expressionForError, Diagnostics.The_iterator_returned_by_the_right_hand_side_of_a_for_of_statement_must_have_a_next_method);
+                    if (errorNode) {
+                        error(errorNode, Diagnostics.An_iterator_must_have_a_next_method);
                     }
                     return undefined;
                 }
@@ -9392,8 +9510,8 @@ module ts {
 
                 let iteratorNextValue = getTypeOfPropertyOfType(iteratorNextResult, "value");
                 if (!iteratorNextValue) {
-                    if (expressionForError) {
-                        error(expressionForError, Diagnostics.The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property);
+                    if (errorNode) {
+                        error(errorNode, Diagnostics.The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property);
                     }
                     return undefined;
                 }
@@ -9419,7 +9537,7 @@ module ts {
          *   1. Some constituent is neither a string nor an array.
          *   2. Some constituent is a string and target is less than ES5 (because in ES3 string is not indexable).
          */
-        function checkElementTypeOfArrayOrString(arrayOrStringType: Type, expressionForError: Expression): Type {
+        function checkElementTypeOfArrayOrString(arrayOrStringType: Type, errorNode: Node): Type {
             Debug.assert(languageVersion < ScriptTarget.ES6);
 
             // After we remove all types that are StringLike, we will know if there was a string constituent
@@ -9430,7 +9548,7 @@ module ts {
             let reportedError = false;
             if (hasStringConstituent) {
                 if (languageVersion < ScriptTarget.ES5) {
-                    error(expressionForError, Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher);
+                    error(errorNode, Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher);
                     reportedError = true;
                 }
 
@@ -9450,7 +9568,7 @@ module ts {
                     let diagnostic = hasStringConstituent
                         ? Diagnostics.Type_0_is_not_an_array_type
                         : Diagnostics.Type_0_is_not_an_array_type_or_a_string_type;
-                    error(expressionForError, diagnostic, typeToString(arrayType));
+                    error(errorNode, diagnostic, typeToString(arrayType));
                 }
                 return hasStringConstituent ? stringType : unknownType;
             }
@@ -9767,6 +9885,10 @@ module ts {
                 grammarErrorOnNode(node, Diagnostics.class_declarations_are_only_supported_directly_inside_a_module_or_as_a_top_level_declaration);
             }
 
+            if (!node.name && !(node.flags & NodeFlags.Default)) {
+                grammarErrorOnFirstToken(node, Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name);
+            }
+
             checkGrammarClassDeclarationHeritageClauses(node);
             checkDecorators(node);
             if (node.name) {
@@ -10767,6 +10889,10 @@ module ts {
                     links.flags |= NodeCheckFlags.EmitDecorate;
                 }
 
+                if (emitParam) {
+                    links.flags |= NodeCheckFlags.EmitParam;
+                }
+
                 links.flags |= NodeCheckFlags.TypeChecked;
             }
         }
@@ -11445,6 +11571,201 @@ module ts {
             return undefined;
         }
 
+        /** Serializes an EntityName (with substitutions) to an appropriate JS constructor value. Used by the __metadata decorator. */
+        function serializeEntityName(node: EntityName, getGeneratedNameForNode: (Node: Node) => string, fallbackPath?: string[]): string {
+            if (node.kind === SyntaxKind.Identifier) {
+                var substitution = getExpressionNameSubstitution(<Identifier>node, getGeneratedNameForNode);
+                var text = substitution || (<Identifier>node).text;
+                if (fallbackPath) {
+                    fallbackPath.push(text);
+                }
+                else {
+                    return text;
+                }
+            }
+            else {
+                var left = serializeEntityName((<QualifiedName>node).left, getGeneratedNameForNode, fallbackPath);
+                var right = serializeEntityName((<QualifiedName>node).right, getGeneratedNameForNode, fallbackPath);
+                if (!fallbackPath) {
+                    return left + "." + right;
+                }
+            }
+        }
+
+        /** Serializes a TypeReferenceNode to an appropriate JS constructor value. Used by the __metadata decorator. */
+        function serializeTypeReferenceNode(node: TypeReferenceNode, getGeneratedNameForNode: (Node: Node) => string): string | string[] {
+            // serialization of a TypeReferenceNode uses the following rules:
+            //
+            // * The serialized type of a TypeReference that is `void` is "void 0".
+            // * The serialized type of a TypeReference that is a `boolean` is "Boolean".
+            // * The serialized type of a TypeReference that is an enum or `number` is "Number".
+            // * The serialized type of a TypeReference that is a string literal or `string` is "String".
+            // * The serialized type of a TypeReference that is a tuple is "Array".
+            // * The serialized type of a TypeReference that is a `symbol` is "Symbol".
+            // * The serialized type of a TypeReference with a value declaration is its entity name.
+            // * The serialized type of a TypeReference with a call or construct signature is "Function".
+            // * The serialized type of any other type is "Object".
+            let type = getTypeFromTypeReference(node);
+            if (type.flags & TypeFlags.Void) {
+                return "void 0";
+            }
+            else if (type.flags & TypeFlags.Boolean) {
+                return "Boolean";
+            }
+            else if (type.flags & TypeFlags.NumberLike) {
+                return "Number";
+            }
+            else if (type.flags & TypeFlags.StringLike) {
+                return "String";
+            }
+            else if (type.flags & TypeFlags.Tuple) {
+                return "Array";
+            }
+            else if (type.flags & TypeFlags.ESSymbol) {
+                return "Symbol";
+            }
+            else if (type === unknownType) {
+                var fallbackPath: string[] = [];
+                serializeEntityName(node.typeName, getGeneratedNameForNode, fallbackPath);
+                return fallbackPath;
+            }
+            else if (type.symbol && type.symbol.valueDeclaration) {
+                return serializeEntityName(node.typeName, getGeneratedNameForNode);
+            }
+            else if (typeHasCallOrConstructSignatures(type)) {
+                return "Function";
+            }
+
+            return "Object";
+        }
+
+        /** Serializes a TypeNode to an appropriate JS constructor value. Used by the __metadata decorator. */
+        function serializeTypeNode(node: TypeNode | LiteralExpression, getGeneratedNameForNode: (Node: Node) => string): string | string[] {
+            // serialization of a TypeNode uses the following rules:
+            //
+            // * The serialized type of `void` is "void 0" (undefined).
+            // * The serialized type of a parenthesized type is the serialized type of its nested type.
+            // * The serialized type of a Function or Constructor type is "Function".
+            // * The serialized type of an Array or Tuple type is "Array".
+            // * The serialized type of `boolean` is "Boolean".
+            // * The serialized type of `string` or a string-literal type is "String".
+            // * The serialized type of a type reference is handled by `serializeTypeReferenceNode`.
+            // * The serialized type of any other type node is "Object".
+            if (node) {
+                switch (node.kind) {
+                    case SyntaxKind.VoidKeyword:
+                        return "void 0";
+                    case SyntaxKind.ParenthesizedType:
+                        return serializeTypeNode((<ParenthesizedTypeNode>node).type, getGeneratedNameForNode);
+                    case SyntaxKind.FunctionType:
+                    case SyntaxKind.ConstructorType:
+                        return "Function";
+                    case SyntaxKind.ArrayType:
+                    case SyntaxKind.TupleType:
+                        return "Array";
+                    case SyntaxKind.BooleanKeyword:
+                        return "Boolean";
+                    case SyntaxKind.StringKeyword:
+                    case SyntaxKind.StringLiteral:
+                        return "String";
+                    case SyntaxKind.NumberKeyword:
+                        return "Number";
+                    case SyntaxKind.TypeReference:
+                        return serializeTypeReferenceNode(<TypeReferenceNode>node, getGeneratedNameForNode);
+                    case SyntaxKind.TypeQuery:
+                    case SyntaxKind.TypeLiteral:
+                    case SyntaxKind.UnionType:
+                    case SyntaxKind.AnyKeyword:
+                        break;
+                    default:
+                        Debug.fail("Cannot serialize unexpected type node.");
+                        break;
+                }
+            }
+             
+            return "Object";
+        }
+
+        /** Serializes the type of a declaration to an appropriate JS constructor value. Used by the __metadata decorator for a class member. */
+        function serializeTypeOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): string | string[] {
+            // serialization of the type of a declaration uses the following rules:
+            //
+            // * The serialized type of a ClassDeclaration is "Function"
+            // * The serialized type of a ParameterDeclaration is the serialized type of its type annotation.
+            // * The serialized type of a PropertyDeclaration is the serialized type of its type annotation.
+            // * The serialized type of an AccessorDeclaration is the serialized type of the return type annotation of its getter or parameter type annotation of its setter.
+            // * The serialized type of any other FunctionLikeDeclaration is "Function".
+            // * The serialized type of any other node is "void 0".
+            // 
+            // For rules on serializing type annotations, see `serializeTypeNode`.
+            switch (node.kind) {
+                case SyntaxKind.ClassDeclaration:       return "Function";
+                case SyntaxKind.PropertyDeclaration:    return serializeTypeNode((<PropertyDeclaration>node).type, getGeneratedNameForNode);
+                case SyntaxKind.Parameter:              return serializeTypeNode((<ParameterDeclaration>node).type, getGeneratedNameForNode);
+                case SyntaxKind.GetAccessor:            return serializeTypeNode((<AccessorDeclaration>node).type, getGeneratedNameForNode);
+                case SyntaxKind.SetAccessor:            return serializeTypeNode(getSetAccessorTypeAnnotationNode(<AccessorDeclaration>node), getGeneratedNameForNode);
+            }
+            if (isFunctionLike(node)) {
+                return "Function";
+            }
+            return "void 0";
+        }
+        
+        /** Serializes the parameter types of a function or the constructor of a class. Used by the __metadata decorator for a method or set accessor. */
+        function serializeParameterTypesOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): (string | string[])[] {
+            // serialization of parameter types uses the following rules:
+            //
+            // * If the declaration is a class, the parameters of the first constructor with a body are used.
+            // * If the declaration is function-like and has a body, the parameters of the function are used.
+            // 
+            // For the rules on serializing the type of each parameter declaration, see `serializeTypeOfDeclaration`.
+            if (node) {
+                var valueDeclaration: FunctionLikeDeclaration;
+                if (node.kind === SyntaxKind.ClassDeclaration) {
+                    valueDeclaration = getFirstConstructorWithBody(<ClassDeclaration>node);
+                }
+                else if (isFunctionLike(node) && nodeIsPresent((<FunctionLikeDeclaration>node).body)) {
+                    valueDeclaration = <FunctionLikeDeclaration>node;
+                }
+                if (valueDeclaration) {
+                    var result: (string | string[])[];
+                    var parameters = valueDeclaration.parameters;
+                    var parameterCount = parameters.length;
+                    if (parameterCount > 0) {
+                        result = new Array<string>(parameterCount);
+                        for (var i = 0; i < parameterCount; i++) {
+                            if (parameters[i].dotDotDotToken) {
+                                var parameterType = parameters[i].type;
+                                if (parameterType.kind === SyntaxKind.ArrayType) {
+                                    parameterType = (<ArrayTypeNode>parameterType).elementType;
+                                }
+                                else if (parameterType.kind === SyntaxKind.TypeReference && (<TypeReferenceNode>parameterType).typeArguments && (<TypeReferenceNode>parameterType).typeArguments.length === 1) {
+                                    parameterType = (<TypeReferenceNode>parameterType).typeArguments[0];
+                                }
+                                else {
+                                    parameterType = undefined;
+                                }
+                                result[i] = serializeTypeNode(parameterType, getGeneratedNameForNode);
+                            }
+                            else {
+                                result[i] = serializeTypeOfNode(parameters[i], getGeneratedNameForNode);
+                            }
+                        }
+                        return result;
+                    }
+                }
+            }
+            return emptyArray;
+        }
+
+        /** Serializes the return type of function. Used by the __metadata decorator for a method. */
+        function serializeReturnTypeOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): string | string[] {
+            if (node && isFunctionLike(node)) {
+                return serializeTypeNode((<FunctionLikeDeclaration>node).type, getGeneratedNameForNode);
+            }
+            return "void 0";
+        }
+
         function writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) {
             // Get type of the symbol if this is the valid symbol otherwise get type at location
             let symbol = getSymbolOfNode(declaration);
@@ -11532,6 +11853,9 @@ module ts {
                 resolvesToSomeValue,
                 collectLinkedAliases,
                 getBlockScopedVariableId,
+                serializeTypeOfNode,
+                serializeParameterTypesOfNode,
+                serializeReturnTypeOfNode,
             };
         }
 
@@ -11596,15 +11920,15 @@ module ts {
                 return false;
             }
             if (!nodeCanBeDecorated(node)) {
-                return grammarErrorOnNode(node, Diagnostics.Decorators_are_not_valid_here);
+                return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_not_valid_here);
             }
             else if (languageVersion < ScriptTarget.ES5) {
-                return grammarErrorOnNode(node, Diagnostics.Decorators_are_only_available_when_targeting_ECMAScript_5_and_higher);
+                return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_only_available_when_targeting_ECMAScript_5_and_higher);
             }
             else if (node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor) {
                 let accessors = getAllAccessorDeclarations((<ClassDeclaration>node.parent).members, <AccessorDeclaration>node);
                 if (accessors.firstAccessor.decorators && node === accessors.secondAccessor) {
-                    return grammarErrorOnNode(node, Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name);
+                    return grammarErrorOnFirstToken(node, Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name);
                 }
             }
             return false;
@@ -12318,7 +12642,9 @@ module ts {
             else {
                 let elements = (<BindingPattern>name).elements;
                 for (let element of elements) {
-                    checkGrammarNameInLetOrConstDeclarations(element.name);
+                    if (element.kind !== SyntaxKind.OmittedExpression) {
+                        checkGrammarNameInLetOrConstDeclarations(element.name);
+                    }
                 }
             }
         }
@@ -12448,7 +12774,16 @@ module ts {
                 let identifier = <Identifier>name;
                 if (contextNode && (contextNode.parserContextFlags & ParserContextFlags.StrictMode) && isEvalOrArgumentsIdentifier(identifier)) {
                     let nameText = declarationNameToString(identifier);
-                    return grammarErrorOnNode(identifier, Diagnostics.Invalid_use_of_0_in_strict_mode, nameText);
+
+                    // We are checking if this name is inside class declaration or class expression (which are under class definitions inside ES6 spec.)
+                    // if so, we would like to give more explicit invalid usage error.
+                    // This will be particularly helpful in the case of "arguments" as such case is very common mistake.
+                    if (getAncestor(name, SyntaxKind.ClassDeclaration) || getAncestor(name, SyntaxKind.ClassExpression)) {
+                        return grammarErrorOnNode(identifier, Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode, nameText);
+                    }
+                    else {
+                        return grammarErrorOnNode(identifier, Diagnostics.Invalid_use_of_0_in_strict_mode, nameText);
+                    }
                 }
             }
         }

src/compiler/commandLineParser.ts

@@ -156,6 +156,11 @@ module ts {
             shortName: "w",
             type: "boolean",
             description: Diagnostics.Watch_input_files,
+        },
+        {
+            name: "emitDecoratorMetadata",
+            type: "boolean",
+            experimental: true
         }
     ];
 

src/compiler/core.ts

@@ -434,7 +434,7 @@ module ts {
         return path.replace(/\\/g, "/");
     }
 
-    // Returns length of path root (i.e. length of "/", "x:/", "//server/share/")
+    // Returns length of path root (i.e. length of "/", "x:/", "//server/share/, file:///user/files")
     export function getRootLength(path: string): number {
         if (path.charCodeAt(0) === CharacterCodes.slash) {
             if (path.charCodeAt(1) !== CharacterCodes.slash) return 1;
@@ -448,6 +448,8 @@ module ts {
             if (path.charCodeAt(2) === CharacterCodes.slash) return 3;
             return 2;
         }
+        let idx = path.indexOf('://');
+        if (idx !== -1) return idx + 3
         return 0;
     }
 

src/compiler/diagnosticInformationMap.generated.ts

@@ -167,6 +167,8 @@ module ts {
         Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name: { code: 1207, category: DiagnosticCategory.Error, key: "Decorators cannot be applied to multiple get/set accessors of the same name." },
         Cannot_compile_non_external_modules_when_the_separateCompilation_flag_is_provided: { code: 1208, category: DiagnosticCategory.Error, key: "Cannot compile non-external modules when the '--separateCompilation' flag is provided." },
         Ambient_const_enums_are_not_allowed_when_the_separateCompilation_flag_is_provided: { code: 1209, category: DiagnosticCategory.Error, key: "Ambient const enums are not allowed when the '--separateCompilation' flag is provided." },
+        Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode: { code: 1210, category: DiagnosticCategory.Error, key: "Invalid use of '{0}'. Class definitions are automatically in strict mode." },
+        A_class_declaration_without_the_default_modifier_must_have_a_name: { code: 1211, category: DiagnosticCategory.Error, key: "A class declaration without the 'default' modifier must have a name" },
         Duplicate_identifier_0: { code: 2300, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." },
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: DiagnosticCategory.Error, key: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
         Static_members_cannot_reference_class_type_parameters: { code: 2302, category: DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." },
@@ -342,8 +344,8 @@ module ts {
         The_left_hand_side_of_a_for_of_statement_cannot_be_a_previously_defined_constant: { code: 2485, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...of' statement cannot be a previously defined constant." },
         The_left_hand_side_of_a_for_in_statement_cannot_be_a_previously_defined_constant: { code: 2486, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...in' statement cannot be a previously defined constant." },
         Invalid_left_hand_side_in_for_of_statement: { code: 2487, category: DiagnosticCategory.Error, key: "Invalid left-hand side in 'for...of' statement." },
-        The_right_hand_side_of_a_for_of_statement_must_have_a_Symbol_iterator_method_that_returns_an_iterator: { code: 2488, category: DiagnosticCategory.Error, key: "The right-hand side of a 'for...of' statement must have a '[Symbol.iterator]()' method that returns an iterator." },
-        The_iterator_returned_by_the_right_hand_side_of_a_for_of_statement_must_have_a_next_method: { code: 2489, category: DiagnosticCategory.Error, key: "The iterator returned by the right-hand side of a 'for...of' statement must have a 'next()' method." },
+        Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator: { code: 2488, category: DiagnosticCategory.Error, key: "Type must have a '[Symbol.iterator]()' method that returns an iterator." },
+        An_iterator_must_have_a_next_method: { code: 2489, category: DiagnosticCategory.Error, key: "An iterator must have a 'next()' method." },
         The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property: { code: 2490, category: DiagnosticCategory.Error, key: "The type returned by the 'next()' method of an iterator must have a 'value' property." },
         The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern: { code: 2491, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...in' statement cannot be a destructuring pattern." },
         Cannot_redeclare_identifier_0_in_catch_clause: { code: 2492, category: DiagnosticCategory.Error, key: "Cannot redeclare identifier '{0}' in catch clause" },
@@ -505,6 +507,22 @@ module ts {
         Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7024, category: DiagnosticCategory.Error, key: "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." },
         You_cannot_rename_this_element: { code: 8000, category: DiagnosticCategory.Error, key: "You cannot rename this element." },
         You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: { code: 8001, category: DiagnosticCategory.Error, key: "You cannot rename elements that are defined in the standard TypeScript library." },
+        import_can_only_be_used_in_a_ts_file: { code: 8002, category: DiagnosticCategory.Error, key: "'import ... =' can only be used in a .ts file." },
+        export_can_only_be_used_in_a_ts_file: { code: 8003, category: DiagnosticCategory.Error, key: "'export=' can only be used in a .ts file." },
+        type_parameter_declarations_can_only_be_used_in_a_ts_file: { code: 8004, category: DiagnosticCategory.Error, key: "'type parameter declarations' can only be used in a .ts file." },
+        implements_clauses_can_only_be_used_in_a_ts_file: { code: 8005, category: DiagnosticCategory.Error, key: "'implements clauses' can only be used in a .ts file." },
+        interface_declarations_can_only_be_used_in_a_ts_file: { code: 8006, category: DiagnosticCategory.Error, key: "'interface declarations' can only be used in a .ts file." },
+        module_declarations_can_only_be_used_in_a_ts_file: { code: 8007, category: DiagnosticCategory.Error, key: "'module declarations' can only be used in a .ts file." },
+        type_aliases_can_only_be_used_in_a_ts_file: { code: 8008, category: DiagnosticCategory.Error, key: "'type aliases' can only be used in a .ts file." },
+        _0_can_only_be_used_in_a_ts_file: { code: 8009, category: DiagnosticCategory.Error, key: "'{0}' can only be used in a .ts file." },
+        types_can_only_be_used_in_a_ts_file: { code: 8010, category: DiagnosticCategory.Error, key: "'types' can only be used in a .ts file." },
+        type_arguments_can_only_be_used_in_a_ts_file: { code: 8011, category: DiagnosticCategory.Error, key: "'type arguments' can only be used in a .ts file." },
+        parameter_modifiers_can_only_be_used_in_a_ts_file: { code: 8012, category: DiagnosticCategory.Error, key: "'parameter modifiers' can only be used in a .ts file." },
+        can_only_be_used_in_a_ts_file: { code: 8013, category: DiagnosticCategory.Error, key: "'?' can only be used in a .ts file." },
+        property_declarations_can_only_be_used_in_a_ts_file: { code: 8014, category: DiagnosticCategory.Error, key: "'property declarations' can only be used in a .ts file." },
+        enum_declarations_can_only_be_used_in_a_ts_file: { code: 8015, category: DiagnosticCategory.Error, key: "'enum declarations' can only be used in a .ts file." },
+        type_assertion_expressions_can_only_be_used_in_a_ts_file: { code: 8016, category: DiagnosticCategory.Error, key: "'type assertion expressions' can only be used in a .ts file." },
+        decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." },
         yield_expressions_are_not_currently_supported: { code: 9000, category: DiagnosticCategory.Error, key: "'yield' expressions are not currently supported." },
         Generators_are_not_currently_supported: { code: 9001, category: DiagnosticCategory.Error, key: "Generators are not currently supported." },
         Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." },

src/compiler/diagnosticMessages.json

@@ -659,6 +659,14 @@
         "category": "Error",
         "code": 1209
     },
+    "Invalid use of '{0}'. Class definitions are automatically in strict mode.": {
+        "category": "Error",
+        "code":  1210
+    },
+    "A class declaration without the 'default' modifier must have a name": {
+        "category": "Error",
+        "code": 1211
+    },
     "Duplicate identifier '{0}'.": {
         "category": "Error",
         "code": 2300
@@ -1359,11 +1367,11 @@
         "category": "Error",
         "code": 2487
     },
-    "The right-hand side of a 'for...of' statement must have a '[Symbol.iterator]()' method that returns an iterator.": {
+    "Type must have a '[Symbol.iterator]()' method that returns an iterator.": {
         "category": "Error",
         "code": 2488
     },
-    "The iterator returned by the right-hand side of a 'for...of' statement must have a 'next()' method.": {
+    "An iterator must have a 'next()' method.": {
         "category": "Error",
         "code": 2489
     },
@@ -2013,6 +2021,71 @@
         "category": "Error",
         "code": 8001
     },
+    "'import ... =' can only be used in a .ts file.": {
+        "category": "Error",
+        "code":  8002
+    },
+    "'export=' can only be used in a .ts file.": {
+        "category": "Error",
+        "code":  8003
+    },
+    "'type parameter declarations' can only be used in a .ts file.": {
+        "category": "Error",
+        "code":  8004
+    },
+    "'implements clauses' can only be used in a .ts file.": {
+        "category": "Error",
+        "code":  8005
+    },
+    "'interface declarations' can only be used in a .ts file.": {
+        "category": "Error",
+        "code": 8006
+    },
+    "'module declarations' can only be used in a .ts file.": {
+        "category": "Error",
+        "code": 8007
+    },
+    "'type aliases' can only be used in a .ts file.": {
+        "category": "Error",
+        "code": 8008
+    },
+    "'{0}' can only be used in a .ts file.": {
+        "category": "Error",
+        "code": 8009
+    },
+    "'types' can only be used in a .ts file.": {
+        "category": "Error",
+        "code": 8010
+    },
+    "'type arguments' can only be used in a .ts file.": {
+        "category": "Error",
+        "code": 8011
+    },
+    "'parameter modifiers' can only be used in a .ts file.": {
+        "category": "Error",
+        "code": 8012
+    },
+    "'?' can only be used in a .ts file.": {
+        "category": "Error",
+        "code": 8013
+    },
+    "'property declarations' can only be used in a .ts file.": {
+        "category": "Error",
+        "code": 8014
+    },
+    "'enum declarations' can only be used in a .ts file.": {
+        "category": "Error",
+        "code": 8015
+    },
+    "'type assertion expressions' can only be used in a .ts file.": {
+        "category": "Error",
+        "code": 8016
+    },
+    "'decorators' can only be used in a .ts file.": {
+        "category": "Error",
+        "code": 8017
+    },
+
     "'yield' expressions are not currently supported.": {
         "category": "Error",
         "code": 9000

src/compiler/parser.ts

@@ -828,7 +828,7 @@ module ts {
         // to reuse are already at the appropriate position in the new text.  That way when we
         // reuse them, we don't have to figure out if they need to be adjusted.  Second, it makes
         // it very easy to determine if we can reuse a node.  If the node's position is at where
-        // we are in the text, then we can reuse it.  Otherwise we can't.  If hte node's position
+        // we are in the text, then we can reuse it.  Otherwise we can't.  If the node's position
         // is ahead of us, then we'll need to rescan tokens.  If the node's position is behind
         // us, then we'll need to skip it or crumble it as appropriate
         //
@@ -1033,7 +1033,7 @@ module ts {
         // that some tokens that would be considered identifiers may be considered keywords.
         //
         // When adding more parser context flags, consider which is the more common case that the
-        // flag will be in.  This should be hte 'false' state for that flag.  The reason for this is
+        // flag will be in.  This should be the 'false' state for that flag.  The reason for this is
         // that we don't store data in our nodes unless the value is in the *non-default* state.  So,
         // for example, more often than code 'allows-in' (or doesn't 'disallow-in').  We opt for
         // 'disallow-in' set to 'false'.  Otherwise, if we had 'allowsIn' set to 'true', then almost
@@ -1044,7 +1044,7 @@ module ts {
         //
         // An important thing about these context concepts.  By default they are effectively inherited
         // while parsing through every grammar production.  i.e. if you don't change them, then when
-        // you parse a sub-production, it will have the same context values as hte parent production.
+        // you parse a sub-production, it will have the same context values as the parent production.
         // This is great most of the time.  After all, consider all the 'expression' grammar productions
         // and how nearly all of them pass along the 'in' and 'yield' context values:
         //
@@ -1836,7 +1836,7 @@ module ts {
             // some node, then we cannot get a node from the old source tree.  This is because we
             // want to mark the next node we encounter as being unusable.
             //
-            // Note: This may be too conservative.  Perhaps we could reuse hte node and set the bit
+            // Note: This may be too conservative.  Perhaps we could reuse the node and set the bit
             // on it (or its leftmost child) as having the error.  For now though, being conservative
             // is nice and likely won't ever affect perf.
             if (parseErrorBeforeNextFinishedNode) {
@@ -4756,15 +4756,13 @@ module ts {
         function parseClassDeclarationOrExpression(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray, kind: SyntaxKind): ClassLikeDeclaration {
             // In ES6 specification, All parts of a ClassDeclaration or a ClassExpression are strict mode code
             let savedStrictModeContext = inStrictModeContext();
-            if (languageVersion >= ScriptTarget.ES6) {
-                setStrictModeContext(true);
-            }
+            setStrictModeContext(true);
 
             var node = <ClassLikeDeclaration>createNode(kind, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
             parseExpected(SyntaxKind.ClassKeyword);
-            node.name = node.flags & NodeFlags.Default ? parseOptionalIdentifier() : parseIdentifier();
+            node.name = parseOptionalIdentifier();
             node.typeParameters = parseTypeParameters();
             node.heritageClauses = parseHeritageClauses(/*isClassHeritageClause:*/ true);
 

src/compiler/types.ts

@@ -933,7 +933,7 @@ module ts {
     // import "mod"  => importClause = undefined, moduleSpecifier = "mod"
     // In rest of the cases, module specifier is string literal corresponding to module
     // ImportClause information is shown at its declaration below.
-    export interface ImportDeclaration extends Statement, ModuleElement {
+    export interface ImportDeclaration extends ModuleElement {
         importClause?: ImportClause;
         moduleSpecifier: Expression;
     }
@@ -1146,7 +1146,7 @@ module ts {
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
         isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean;
         getAliasedSymbol(symbol: Symbol): Symbol;
-        getExportsOfExternalModule(node: ImportDeclaration): Symbol[];
+        getExportsOfModule(moduleSymbol: Symbol): Symbol[];
 
         // Should not be called directly.  Should only be accessed through the Program instance.
         /* @internal */ getDiagnostics(sourceFile?: SourceFile): Diagnostic[];
@@ -1255,6 +1255,9 @@ module ts {
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
         resolvesToSomeValue(location: Node, name: string): boolean;
         getBlockScopedVariableId(node: Identifier): number;
+        serializeTypeOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): string | string[];
+        serializeParameterTypesOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): (string | string[])[];
+        serializeReturnTypeOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): string | string[];
     }
 
     export const enum SymbolFlags {
@@ -1380,6 +1383,7 @@ module ts {
         EnumValuesComputed          = 0x00000080,
         BlockScopedBindingInLoop    = 0x00000100,
         EmitDecorate                = 0x00000200,  // Emit __decorate
+        EmitParam                   = 0x00000400,  // Emit __param helper for decorators
     }
 
     export interface NodeLinks {
@@ -1605,6 +1609,7 @@ module ts {
         version?: boolean;
         watch?: boolean;
         separateCompilation?: boolean;
+        emitDecoratorMetadata?: boolean;
         /* @internal */ stripInternal?: boolean;
         [option: string]: string | number | boolean;
     }

src/compiler/utilities.ts

@@ -449,6 +449,18 @@ module ts {
         return false;
     }
 
+    export function isAccessor(node: Node): boolean {
+        if (node) {
+            switch (node.kind) {
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
     export function isFunctionLike(node: Node): boolean {
         if (node) {
             switch (node.kind) {
@@ -514,6 +526,19 @@ module ts {
                     // the *body* of the container.
                     node = node.parent;
                     break;
+                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)) {
+                        // If the decorator's parent is a Parameter, we resolve the this container from
+                        // the grandparent class declaration.
+                        node = node.parent.parent;
+                    }
+                    else if (isClassElement(node.parent)) {
+                        // If the decorator's parent is a class element, we resolve the 'this' container
+                        // from the parent class declaration.
+                        node = node.parent;
+                    }
+                    break;
                 case SyntaxKind.ArrowFunction:
                     if (!includeArrowFunctions) {
                         continue;
@@ -556,6 +581,19 @@ module ts {
                     // the *body* of the container.
                     node = node.parent;
                     break;
+                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)) {
+                        // If the decorator's parent is a Parameter, we resolve the this container from
+                        // the grandparent class declaration.
+                        node = node.parent.parent;
+                    }
+                    else if (isClassElement(node.parent)) {
+                        // If the decorator's parent is a class element, we resolve the 'this' container
+                        // from the parent class declaration.
+                        node = node.parent;
+                    }
+                    break;
                 case SyntaxKind.FunctionDeclaration:
                 case SyntaxKind.FunctionExpression:
                 case SyntaxKind.ArrowFunction:
@@ -907,6 +945,7 @@ module ts {
             case SyntaxKind.MethodDeclaration:
             case SyntaxKind.GetAccessor:
             case SyntaxKind.SetAccessor:
+            case SyntaxKind.MethodSignature:
             case SyntaxKind.IndexSignature:
                 return true;
             default:

src/harness/fourslash.ts

@@ -14,6 +14,7 @@
 //
 
 /// <reference path='..\services\services.ts' />
+/// <reference path='..\services\shims.ts' />
 /// <reference path='harnessLanguageService.ts' />
 /// <reference path='harness.ts' />
 /// <reference path='fourslashRunner.ts' />
@@ -115,7 +116,7 @@ module FourSlash {
     // Name of testcase metadata including ts.CompilerOptions properties that will be used by globalOptions
     // To add additional option, add property into the testOptMetadataNames, refer the property in either globalMetadataNames or fileMetadataNames
     // Add cases into convertGlobalOptionsToCompilationsSettings function for the compiler to acknowledge such option from meta data
-    var testOptMetadataNames = {
+    var metadataOptionNames = {
         baselineFile: 'BaselineFile',
         declaration: 'declaration',
         emitThisFile: 'emitThisFile',  // This flag is used for testing getEmitOutput feature. It allows test-cases to indicate what file to be output in multiple files project
@@ -126,14 +127,15 @@ module FourSlash {
         outDir: 'outDir',
         sourceMap: 'sourceMap',
         sourceRoot: 'sourceRoot',
+        allowNonTsExtensions: 'allowNonTsExtensions',
         resolveReference: 'ResolveReference',  // This flag is used to specify entry file for resolve file references. The flag is only allow once per test file
     };
 
     // List of allowed metadata names
-    var fileMetadataNames = [testOptMetadataNames.fileName, testOptMetadataNames.emitThisFile, testOptMetadataNames.resolveReference];
-    var globalMetadataNames = [testOptMetadataNames.baselineFile, testOptMetadataNames.declaration,
-        testOptMetadataNames.mapRoot, testOptMetadataNames.module, testOptMetadataNames.out,
-        testOptMetadataNames.outDir, testOptMetadataNames.sourceMap, testOptMetadataNames.sourceRoot]
+    var fileMetadataNames = [metadataOptionNames.fileName, metadataOptionNames.emitThisFile, metadataOptionNames.resolveReference];
+    var globalMetadataNames = [metadataOptionNames.allowNonTsExtensions, metadataOptionNames.baselineFile, metadataOptionNames.declaration,
+        metadataOptionNames.mapRoot, metadataOptionNames.module, metadataOptionNames.out,
+        metadataOptionNames.outDir, metadataOptionNames.sourceMap, metadataOptionNames.sourceRoot]
 
     function convertGlobalOptionsToCompilerOptions(globalOptions: { [idx: string]: string }): ts.CompilerOptions {
         var settings: ts.CompilerOptions = { target: ts.ScriptTarget.ES5 };
@@ -141,13 +143,16 @@ module FourSlash {
         for (var prop in globalOptions) {
             if (globalOptions.hasOwnProperty(prop)) {
                 switch (prop) {
-                    case testOptMetadataNames.declaration:
+                    case metadataOptionNames.allowNonTsExtensions:
+                        settings.allowNonTsExtensions = true;
+                        break;
+                    case metadataOptionNames.declaration:
                         settings.declaration = true;
                         break;
-                    case testOptMetadataNames.mapRoot:
+                    case metadataOptionNames.mapRoot:
                         settings.mapRoot = globalOptions[prop];
                         break;
-                    case testOptMetadataNames.module:
+                    case metadataOptionNames.module:
                         // create appropriate external module target for CompilationSettings
                         switch (globalOptions[prop]) {
                             case "AMD":
@@ -162,16 +167,16 @@ module FourSlash {
                                 break;
                         }
                         break;
-                    case testOptMetadataNames.out:
+                    case metadataOptionNames.out:
                         settings.out = globalOptions[prop];
                         break;
-                    case testOptMetadataNames.outDir:
+                    case metadataOptionNames.outDir:
                         settings.outDir = globalOptions[prop];
                         break;
-                    case testOptMetadataNames.sourceMap:
+                    case metadataOptionNames.sourceMap:
                         settings.sourceMap = true;
                         break;
-                    case testOptMetadataNames.sourceRoot:
+                    case metadataOptionNames.sourceRoot:
                         settings.sourceRoot = globalOptions[prop];
                         break;
                 }
@@ -303,7 +308,7 @@ module FourSlash {
             ts.forEach(testData.files, file => {
                 // Create map between fileName and its content for easily looking up when resolveReference flag is specified
                 this.inputFiles[file.fileName] = file.content;
-                if (!startResolveFileRef && file.fileOptions[testOptMetadataNames.resolveReference]) {
+                if (!startResolveFileRef && file.fileOptions[metadataOptionNames.resolveReference]) {
                     startResolveFileRef = file;
                 } else if (startResolveFileRef) {
                     // If entry point for resolving file references is already specified, report duplication error
@@ -793,6 +798,13 @@ module FourSlash {
             return "\nActual " + name + ":\n\t" + actualValue + "\nExpected value:\n\t" + expectedValue;
         }
 
+        public getSemanticDiagnostics(expected: string) {
+            var diagnostics = this.languageService.getSemanticDiagnostics(this.activeFile.fileName);
+            var realized = ts.realizeDiagnostics(diagnostics, "\r\n");
+            var actual = JSON.stringify(realized, null, "  ");
+            assert.equal(actual, expected);
+        }
+
         public verifyQuickInfoString(negative: boolean, expectedText?: string, expectedDocumentation?: string) {
             [expectedText, expectedDocumentation].forEach(str => {
                 if (str) {
@@ -1131,7 +1143,7 @@ module FourSlash {
 
             Harness.Baseline.runBaseline(
                 "Breakpoint Locations for " + this.activeFile.fileName,
-                this.testData.globalOptions[testOptMetadataNames.baselineFile],
+                this.testData.globalOptions[metadataOptionNames.baselineFile],
                 () => {
                     return this.baselineCurrentFileLocations(pos => this.getBreakpointStatementLocation(pos));
                 },
@@ -1146,7 +1158,7 @@ module FourSlash {
             var allFourSlashFiles = this.testData.files;
             for (var idx = 0; idx < allFourSlashFiles.length; ++idx) {
                 var file = allFourSlashFiles[idx];
-                if (file.fileOptions[testOptMetadataNames.emitThisFile]) {
+                if (file.fileOptions[metadataOptionNames.emitThisFile]) {
                     // Find a file with the flag emitThisFile turned on
                     emitFiles.push(file);
                 }
@@ -1159,7 +1171,7 @@ module FourSlash {
 
             Harness.Baseline.runBaseline(
                 "Generate getEmitOutput baseline : " + emitFiles.join(" "),
-                this.testData.globalOptions[testOptMetadataNames.baselineFile],
+                this.testData.globalOptions[metadataOptionNames.baselineFile],
                 () => {
                     var resultString = "";
                     // Loop through all the emittedFiles and emit them one by one
@@ -1704,7 +1716,7 @@ module FourSlash {
 
             Harness.Baseline.runBaseline(
                 "Name OrDottedNameSpans for " + this.activeFile.fileName,
-                this.testData.globalOptions[testOptMetadataNames.baselineFile],
+                this.testData.globalOptions[metadataOptionNames.baselineFile],
                 () => {
                     return this.baselineCurrentFileLocations(pos =>
                         this.getNameOrDottedNameSpan(pos));
@@ -2280,7 +2292,7 @@ module FourSlash {
                     if (globalMetadataNamesIndex === -1) {
                         if (fileMetadataNamesIndex === -1) {
                             throw new Error('Unrecognized metadata name "' + match[1] + '". Available global metadata names are: ' + globalMetadataNames.join(', ') + '; file metadata names are: ' + fileMetadataNames.join(', '));
-                        } else if (fileMetadataNamesIndex === fileMetadataNames.indexOf(testOptMetadataNames.fileName)) {
+                        } else if (fileMetadataNamesIndex === fileMetadataNames.indexOf(metadataOptionNames.fileName)) {
                             // Found an @FileName directive, if this is not the first then create a new subfile
                             if (currentFileContent) {
                                 var file = parseFileContent(currentFileContent, currentFileName, markerPositions, markers, ranges);

src/harness/harness.ts

@@ -781,7 +781,7 @@ module Harness {
 
             public reset() { this.fileCollection = {}; }
 
-            public toArray(): { fileName: string; file: WriterAggregator; }[] {
+            public toArray(): { fileName: string; file: WriterAggregator; }[]{
                 var result: { fileName: string; file: WriterAggregator; }[] = [];
                 for (var p in this.fileCollection) {
                     if (this.fileCollection.hasOwnProperty(p)) {
@@ -944,6 +944,10 @@ module Harness {
 
                 var newLine = '\r\n';
 
+                // Files from built\local that are requested by test "@includeBuiltFiles" to be in the context.
+                // Treat them as library files, so include them in build, but not in baselines.
+                var includeBuiltFiles: { unitName: string; content: string }[] = [];
+
                 var useCaseSensitiveFileNames = ts.sys.useCaseSensitiveFileNames;
                 this.settings.forEach(setting => {
                     switch (setting.flag.toLowerCase()) {
@@ -1061,18 +1065,19 @@ module Harness {
                             break;
 
                         case 'includebuiltfile':
-                            inputFiles.push({ unitName: setting.value, content: normalizeLineEndings(IO.readFile(libFolder + setting.value), newLine) });
+                            let builtFileName = libFolder + setting.value;
+                            includeBuiltFiles.push({ unitName: builtFileName, content: normalizeLineEndings(IO.readFile(builtFileName), newLine) });
                             break;
 
                         default:
                             throw new Error('Unsupported compiler setting ' + setting.flag);
                     }
                 });
-
+                
                 var fileOutputs: GeneratedFile[] = [];
                 
-                var programFiles = inputFiles.map(file => file.unitName);
-                var program = ts.createProgram(programFiles, options, createCompilerHost(inputFiles.concat(otherFiles),
+                var programFiles = inputFiles.concat(includeBuiltFiles).map(file => file.unitName);
+                var program = ts.createProgram(programFiles, options, createCompilerHost(inputFiles.concat(includeBuiltFiles).concat(otherFiles),
                     (fn, contents, writeByteOrderMark) => fileOutputs.push({ fileName: fn, code: contents, writeByteOrderMark: writeByteOrderMark }),
                     options.target, useCaseSensitiveFileNames, currentDirectory));
 
@@ -1295,7 +1300,7 @@ module Harness {
             });
 
             var numLibraryDiagnostics = ts.countWhere(diagnostics, diagnostic => {
-                return diagnostic.fileName && isLibraryFile(diagnostic.fileName);
+                return diagnostic.fileName && (isLibraryFile(diagnostic.fileName) || isBuiltFile(diagnostic.fileName));
             });
 
             var numTest262HarnessDiagnostics = ts.countWhere(diagnostics, diagnostic => {
@@ -1698,6 +1703,10 @@ module Harness {
         return (Path.getFileName(filePath) === 'lib.d.ts') || (Path.getFileName(filePath) === 'lib.core.d.ts');
     }
 
+    export function isBuiltFile(filePath: string): boolean {
+        return filePath.indexOf(Harness.libFolder) === 0;
+    }
+
     export function getDefaultLibraryFile(): { unitName: string, content: string } {
         var libFile = Harness.userSpecifiedroot + Harness.libFolder + "/" + "lib.d.ts";
         return {

src/harness/typeWriter.ts

@@ -52,6 +52,7 @@ class TypeWriterWalker {
             case ts.SyntaxKind.PostfixUnaryExpression:
             case ts.SyntaxKind.BinaryExpression:
             case ts.SyntaxKind.ConditionalExpression:
+            case ts.SyntaxKind.SpreadElementExpression:
                 this.log(node, this.getTypeOfNode(node));
                 break;
 

src/lib/core.d.ts

@@ -1168,4 +1168,4 @@ interface TypedPropertyDescriptor<T> {
 declare type ClassDecorator = <TFunction extends Function>(target: TFunction) => TFunction | void;
 declare type PropertyDecorator = (target: Object, propertyKey: string | symbol) => void;
 declare type MethodDecorator = <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
-declare type ParameterDecorator = (target: Function, propertyKey: string | symbol, parameterIndex: number) => void;
+declare type ParameterDecorator = (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;

src/lib/es6.d.ts

@@ -3513,27 +3513,27 @@ interface ProxyHandler<T> {
 
 interface ProxyConstructor {
     revocable<T>(target: T, handler: ProxyHandler<T>): { proxy: T; revoke: () => void; };
-    new <T>(target: T, handeler: ProxyHandler<T>): T
+    new <T>(target: T, handler: ProxyHandler<T>): T
 }
 declare var Proxy: ProxyConstructor;
 
-declare var Reflect: {
-    apply(target: Function, thisArgument: any, argumentsList: ArrayLike<any>): any;
-    construct(target: Function, argumentsList: ArrayLike<any>): any;
-    defineProperty(target: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean;
-    deleteProperty(target: any, propertyKey: PropertyKey): boolean;
-    enumerate(target: any): IterableIterator<any>;
-    get(target: any, propertyKey: PropertyKey, receiver?: any): any;
-    getOwnPropertyDescriptor(target: any, propertyKey: PropertyKey): PropertyDescriptor;
-    getPrototypeOf(target: any): any;
-    has(target: any, propertyKey: string): boolean;
-    has(target: any, propertyKey: symbol): boolean;
-    isExtensible(target: any): boolean;
-    ownKeys(target: any): Array<PropertyKey>;
-    preventExtensions(target: any): boolean;
-    set(target: any, propertyKey: PropertyKey, value: any, receiver? :any): boolean;
-    setPrototypeOf(target: any, proto: any): boolean;
-};
+declare module Reflect {
+    function apply(target: Function, thisArgument: any, argumentsList: ArrayLike<any>): any;
+    function construct(target: Function, argumentsList: ArrayLike<any>): any;
+    function defineProperty(target: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean;
+    function deleteProperty(target: any, propertyKey: PropertyKey): boolean;
+    function enumerate(target: any): IterableIterator<any>;
+    function get(target: any, propertyKey: PropertyKey, receiver?: any): any;
+    function getOwnPropertyDescriptor(target: any, propertyKey: PropertyKey): PropertyDescriptor;
+    function getPrototypeOf(target: any): any;
+    function has(target: any, propertyKey: string): boolean;
+    function has(target: any, propertyKey: symbol): boolean;
+    function isExtensible(target: any): boolean;
+    function ownKeys(target: any): Array<PropertyKey>;
+    function preventExtensions(target: any): boolean;
+    function set(target: any, propertyKey: PropertyKey, value: any, receiver? :any): boolean;
+    function setPrototypeOf(target: any, proto: any): boolean;
+}
 
 /**
  * Represents the completion of an asynchronous operation

src/server/client.ts

@@ -68,12 +68,12 @@ module ts.server {
             };
         }
 
-        private processRequest<T extends protocol.Request>(command: string, arguments?: any): T {
+        private processRequest<T extends protocol.Request>(command: string, args?: any): T {
             var request: protocol.Request = {
                 seq: this.sequence++,
                 type: "request",
-                command: command,
-                arguments: arguments
+                arguments: args,
+                command
             };
 
             this.writeMessage(JSON.stringify(request));
@@ -104,7 +104,7 @@ module ts.server {
                 var response: T = JSON.parse(responseBody);
             }
             catch (e) {
-                throw new Error("Malformed response: Failed to parse server response: " + lastMessage + ". \r\n  Error detailes: " + e.message);
+                throw new Error("Malformed response: Failed to parse server response: " + lastMessage + ". \r\n  Error details: " + e.message);
             }
 
             // verify the sequence numbers
@@ -446,6 +446,7 @@ module ts.server {
             if (!response.body) {
                 return undefined;
             }
+
             var helpItems: protocol.SignatureHelpItems = response.body;
             var span = helpItems.applicableSpan;
             var start = this.lineOffsetToPosition(fileName, span.start);
@@ -465,7 +466,26 @@ module ts.server {
         }
 
         getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[] {
-            throw new Error("Not Implemented Yet.");
+            var lineOffset = this.positionToOneBasedLineOffset(fileName, position);
+            var args: protocol.FileLocationRequestArgs = {
+                file: fileName,
+                line: lineOffset.line,
+                offset: lineOffset.offset,
+            };
+
+            var request = this.processRequest<protocol.OccurrencesRequest>(CommandNames.Occurrences, args);
+            var response = this.processResponse<protocol.OccurrencesResponse>(request);
+
+            return response.body.map(entry => {
+                var fileName = entry.file;
+                var start = this.lineOffsetToPosition(fileName, entry.start);
+                var end = this.lineOffsetToPosition(fileName, entry.end);
+                return {
+                    fileName,
+                    textSpan: ts.createTextSpanFromBounds(start, end),
+                    isWriteAccess: entry.isWriteAccess,
+                };
+            });
         }
 
         getOutliningSpans(fileName: string): OutliningSpan[] {

src/server/editorServices.ts

@@ -458,7 +458,7 @@ module ts.server {
                 var info = this.filenameToScriptInfo[args.file];
                 if (info) {
                     info.setFormatOptions(args.formatOptions);  
-                    this.log("Host configuration update for file " + args.file);
+                    this.log("Host configuration update for file " + args.file, "Info");
                 }
             }
             else {
@@ -823,7 +823,6 @@ module ts.server {
          */
 
         closeClientFile(filename: string) {
-            // TODO: tsconfig check
             var info = ts.lookUp(this.filenameToScriptInfo, filename);
             if (info) {
                 this.closeOpenFile(info);
@@ -856,6 +855,9 @@ module ts.server {
         }
 
         printProjects() {
+            if (!this.psLogger.isVerbose()) {
+                return;
+            }
             this.psLogger.startGroup();
             for (var i = 0, len = this.inferredProjects.length; i < len; i++) {
                 var project = this.inferredProjects[i];
@@ -1466,6 +1468,10 @@ module ts.server {
             return accum;
         }
 
+        getLength(): number {
+            return this.root.charCount();
+        }
+
         every(f: (ll: LineLeaf, s: number, len: number) => boolean, rangeStart: number, rangeEnd?: number) {
             if (!rangeEnd) {
                 rangeEnd = this.root.charCount();

src/server/protocol.d.ts

@@ -165,6 +165,25 @@ declare module ts.server.protocol {
         body?: FileSpan[];
     }
 
+    /**
+      * Get occurrences request; value of command field is
+      * "occurrences". Return response giving spans that are relevant
+      * in the file at a given line and column.
+      */
+    export interface OccurrencesRequest extends FileLocationRequest {
+    }
+
+    export interface OccurrencesResponseItem extends FileSpan {
+        /**
+          * True if the occurrence is a write location, false otherwise.
+          */
+        isWriteAccess: boolean;
+    }
+
+    export interface OccurrencesResponse extends Response {
+        body?: OccurrencesResponseItem[];
+    }
+
     /**
       * Find references request; value of command field is
       * "references". Return response giving the file locations that
@@ -405,6 +424,13 @@ declare module ts.server.protocol {
         arguments: OpenRequestArgs;
     }
 
+    /**
+      *  Exit request; value of command field is "exit".  Ask the server process
+      *  to exit.
+      */
+    export interface ExitRequest extends Request {
+    }
+
     /**
       * Close request; value of command field is "close". Notify the
       * server that the client has closed a previously open file.  If
@@ -617,12 +643,29 @@ declare module ts.server.protocol {
           * Optional modifiers for the kind (such as 'public').
           */
         kindModifiers: string;
+        /** 
+         * A string that is used for comparing completion items so that they can be ordered.  This
+         * is often the same as the name but may be different in certain circumstances.
+         */
+        sortText: string;
     }
 
     /**
       * Additional completion entry details, available on demand
       */
-    export interface CompletionEntryDetails extends CompletionEntry {
+    export interface CompletionEntryDetails {
+        /**
+          * The symbol's name.
+          */
+        name: string;
+        /**
+          * The symbol's kind (such as 'className' or 'parameterName').
+          */
+        kind: string;
+        /**
+          * Optional modifiers for the kind (such as 'public').
+          */
+        kindModifiers: string;
         /**
           * Display parts of the symbol (similar to quick info).
           */

src/server/server.ts

@@ -177,6 +177,12 @@ module ts.server {
             super(host, logger);
         }
 
+        exit() {
+            this.projectService.log("Exiting...","Info");
+            this.projectService.closeLog();
+            process.exit(0);
+        }
+
         listen() {
             rl.on('line',(input: string) => {
                 var message = input.trim();
@@ -184,9 +190,7 @@ module ts.server {
             });
 
             rl.on('close',() => {
-                this.projectService.log("Exiting...");
-                this.projectService.closeLog();
-                process.exit(0);
+                this.exit();
             });
         }
     }

src/server/session.ts

@@ -76,25 +76,27 @@ module ts.server {
     }
 
     export module CommandNames {
+        export var Brace = "brace";
         export var Change = "change";
         export var Close = "close";
         export var Completions = "completions";
         export var CompletionDetails = "completionEntryDetails";
-        export var SignatureHelp = "signatureHelp";        
         export var Configure = "configure";
         export var Definition = "definition";
+        export var Exit = "exit";
         export var Format = "format";
         export var Formatonkey = "formatonkey";
         export var Geterr = "geterr";
         export var NavBar = "navbar";
         export var Navto = "navto";
+        export var Occurrences = "occurrences";
         export var Open = "open";
         export var Quickinfo = "quickinfo";
         export var References = "references";
         export var Reload = "reload";
         export var Rename = "rename";
         export var Saveto = "saveto";
-        export var Brace = "brace";
+        export var SignatureHelp = "signatureHelp";        
         export var Unknown = "unknown";
     }
 
@@ -116,7 +118,7 @@ module ts.server {
 
         constructor(private host: ServerHost, private logger: Logger) {
             this.projectService =
-                new ProjectService(host, logger, (eventName,project,fileName) => {
+            new ProjectService(host, logger, (eventName, project, fileName) => {
                 this.handleEvent(eventName, project, fileName);
             });
         }
@@ -261,7 +263,7 @@ module ts.server {
             }
         }
 
-        getDefinition(line: number, offset: number, fileName: string): protocol.FileSpan[] {
+        getDefinition({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.FileSpan[] {
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
@@ -283,7 +285,37 @@ module ts.server {
             }));
         }
 
-        getRenameLocations(line: number, offset: number, fileName: string,findInComments: boolean, findInStrings: boolean): protocol.RenameResponseBody {
+        getOccurrences({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.OccurrencesResponseItem[] {
+            fileName = ts.normalizePath(fileName);
+            let project = this.projectService.getProjectForFile(fileName);
+
+            if (!project) {
+                throw Errors.NoProject;
+            }
+
+            let { compilerService } = project;
+            let position = compilerService.host.lineOffsetToPosition(fileName, line, offset);
+
+            let occurrences = compilerService.languageService.getOccurrencesAtPosition(fileName, position);
+
+            if (!occurrences) {
+                return undefined;
+            }
+
+            return occurrences.map(occurrence => {
+                let { fileName, isWriteAccess, textSpan } = occurrence;
+                let start = compilerService.host.positionToLineOffset(fileName, textSpan.start);
+                let end = compilerService.host.positionToLineOffset(fileName, ts.textSpanEnd(textSpan));
+                return {
+                    start,
+                    end,
+                    file: fileName,
+                    isWriteAccess
+                }
+            });
+        }
+
+        getRenameLocations({line, offset, file: fileName, findInComments, findInStrings }: protocol.RenameRequestArgs): protocol.RenameResponseBody {
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
@@ -351,7 +383,7 @@ module ts.server {
             return { info: renameInfo, locs: bakedRenameLocs };
         }
 
-        getReferences(line: number, offset: number, fileName: string): protocol.ReferencesResponseBody {
+        getReferences({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.ReferencesResponseBody {
             // TODO: get all projects for this file; report refs for all projects deleting duplicates
             // can avoid duplicates by eliminating same ref file from subsequent projects
             var file = ts.normalizePath(fileName);
@@ -377,7 +409,7 @@ module ts.server {
             var nameSpan = nameInfo.textSpan;
             var nameColStart = compilerService.host.positionToLineOffset(file, nameSpan.start).offset;
             var nameText = compilerService.host.getScriptSnapshot(file).getText(nameSpan.start, ts.textSpanEnd(nameSpan));
-            var bakedRefs: protocol.ReferencesResponseItem[] = references.map((ref) => {
+            var bakedRefs: protocol.ReferencesResponseItem[] = references.map(ref => {
                 var start = compilerService.host.positionToLineOffset(ref.fileName, ref.textSpan.start);
                 var refLineSpan = compilerService.host.lineToTextSpan(ref.fileName, start.line - 1);
                 var snap = compilerService.host.getScriptSnapshot(ref.fileName);
@@ -398,12 +430,12 @@ module ts.server {
             };
         }
 
-        openClientFile(fileName: string) {
+        openClientFile({ file: fileName }: protocol.OpenRequestArgs) {
             var file = ts.normalizePath(fileName);
             this.projectService.openClientFile(file);
         }
 
-        getQuickInfo(line: number, offset: number, fileName: string): protocol.QuickInfoResponseBody {
+        getQuickInfo({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.QuickInfoResponseBody {
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
@@ -429,7 +461,7 @@ module ts.server {
             };
         }
 
-        getFormattingEditsForRange(line: number, offset: number, endLine: number, endOffset: number, fileName: string): protocol.CodeEdit[] {
+        getFormattingEditsForRange({line, offset, endLine, endOffset, file: fileName}: protocol.FormatRequestArgs): protocol.CodeEdit[] {
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
@@ -456,7 +488,7 @@ module ts.server {
             });
         }
 
-        getFormattingEditsAfterKeystroke(line: number, offset: number, key: string, fileName: string): protocol.CodeEdit[] {
+        getFormattingEditsAfterKeystroke({line, offset, key, file: fileName}: protocol.FormatOnKeyRequestArgs): protocol.CodeEdit[] {
             var file = ts.normalizePath(fileName);
 
             var project = this.projectService.getProjectForFile(file);
@@ -529,7 +561,7 @@ module ts.server {
             });
         }
 
-        getCompletions(line: number, offset: number, prefix: string, fileName: string): protocol.CompletionEntry[] {
+        getCompletions({ line, offset, prefix, file: fileName}: protocol.CompletionsRequestArgs): protocol.CompletionEntry[] {
             if (!prefix) {
                 prefix = "";
             }
@@ -555,8 +587,7 @@ module ts.server {
             }, []).sort((a, b) => a.name.localeCompare(b.name));
         }
 
-        getCompletionEntryDetails(line: number, offset: number,
-            entryNames: string[], fileName: string): protocol.CompletionEntryDetails[] {
+        getCompletionEntryDetails({ line, offset, entryNames, file: fileName}: protocol.CompletionDetailsRequestArgs): protocol.CompletionEntryDetails[] {
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
@@ -575,20 +606,20 @@ module ts.server {
             }, []);
         }
 
-        getSignatureHelpItems(line: number, offset: number, fileName: string): protocol.SignatureHelpItems {
+        getSignatureHelpItems({ line, offset, file: fileName }: protocol.SignatureHelpRequestArgs): protocol.SignatureHelpItems {
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
                 throw Errors.NoProject;
             }
-            
+
             var compilerService = project.compilerService;
             var position = compilerService.host.lineOffsetToPosition(file, line, offset);
             var helpItems = compilerService.languageService.getSignatureHelpItems(file, position);
             if (!helpItems) {
                 return undefined;
             }
-            
+
             var span = helpItems.applicableSpan;
             var result: protocol.SignatureHelpItems = {
                 items: helpItems.items,
@@ -600,11 +631,11 @@ module ts.server {
                 argumentIndex: helpItems.argumentIndex,
                 argumentCount: helpItems.argumentCount,
             }
-            
+
             return result;
         }
-                
-        getDiagnostics(delay: number, fileNames: string[]) {
+
+        getDiagnostics({ delay, files: fileNames }: protocol.GeterrRequestArgs): void {
             var checkList = fileNames.reduce((accum: PendingErrorCheck[], fileName: string) => {
                 fileName = ts.normalizePath(fileName);
                 var project = this.projectService.getProjectForFile(fileName);
@@ -615,11 +646,11 @@ module ts.server {
             }, []);
 
             if (checkList.length > 0) {
-                this.updateErrorCheck(checkList, this.changeSeq,(n) => n == this.changeSeq, delay)
+                this.updateErrorCheck(checkList, this.changeSeq, (n) => n == this.changeSeq, delay)
             }
         }
 
-        change(line: number, offset: number, endLine: number, endOffset: number, insertString: string, fileName: string) {
+        change({ line, offset, endLine, endOffset, insertString, file: fileName }: protocol.ChangeRequestArgs): void {
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (project) {
@@ -634,7 +665,7 @@ module ts.server {
             }
         }
 
-        reload(fileName: string, tempFileName: string, reqSeq = 0) {
+        reload({ file: fileName, tmpfile: tempFileName }: protocol.ReloadRequestArgs, reqSeq = 0): void {
             var file = ts.normalizePath(fileName);
             var tmpfile = ts.normalizePath(tempFileName);
             var project = this.projectService.getProjectForFile(file);
@@ -647,7 +678,7 @@ module ts.server {
             }
         }
 
-        saveToTmp(fileName: string, tempFileName: string) {
+        saveToTmp({ file: fileName, tmpfile: tempFileName }: protocol.SavetoRequestArgs): void {
             var file = ts.normalizePath(fileName);
             var tmpfile = ts.normalizePath(tempFileName);
 
@@ -657,7 +688,7 @@ module ts.server {
             }
         }
 
-        closeClientFile(fileName: string) {
+        closeClientFile({ file: fileName }: protocol.FileRequestArgs) {
             var file = ts.normalizePath(fileName);
             this.projectService.closeClientFile(file);
         }
@@ -681,7 +712,7 @@ module ts.server {
             }));
         }
 
-        getNavigationBarItems(fileName: string): protocol.NavigationBarItem[] {
+        getNavigationBarItems({ file: fileName }: protocol.FileRequestArgs): protocol.NavigationBarItem[]{
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
@@ -697,7 +728,7 @@ module ts.server {
             return this.decorateNavigationBarItem(project, fileName, items);
         }
 
-        getNavigateToItems(searchValue: string, fileName: string, maxResultCount?: number): protocol.NavtoItem[] {
+        getNavigateToItems({ searchValue, file: fileName, maxResultCount }: protocol.NavtoRequestArgs): protocol.NavtoItem[]{
             var file = ts.normalizePath(fileName);
             var project = this.projectService.getProjectForFile(file);
             if (!project) {
@@ -736,7 +767,7 @@ module ts.server {
             });
         }
 
-        getBraceMatching(line: number, offset: number, fileName: string): protocol.TextSpan[] {
+        getBraceMatching({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.TextSpan[]{
             var file = ts.normalizePath(fileName);
             
             var project = this.projectService.getProjectForFile(file);
@@ -758,6 +789,9 @@ module ts.server {
             }));
         }
 
+        exit() {
+        }
+
         onMessage(message: string) {
             if (this.logger.isVerbose()) {
                 this.logger.info("request: " + message);
@@ -769,110 +803,97 @@ module ts.server {
                 var errorMessage: string;
                 var responseRequired = true;
                 switch (request.command) {
+                    case CommandNames.Exit: {
+                        this.exit();
+                        responseRequired = false;
+                        break;
+                    }
                     case CommandNames.Definition: { 
-                        var defArgs = <protocol.FileLocationRequestArgs>request.arguments;
-                        response = this.getDefinition(defArgs.line, defArgs.offset, defArgs.file);
+                        response = this.getDefinition(<protocol.FileLocationRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.References: { 
-                        var refArgs = <protocol.FileLocationRequestArgs>request.arguments;
-                        response = this.getReferences(refArgs.line, refArgs.offset, refArgs.file);
+                        response = this.getReferences(<protocol.FileLocationRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.Rename: {
-                        var renameArgs = <protocol.RenameRequestArgs>request.arguments;
-                        response = this.getRenameLocations(renameArgs.line, renameArgs.offset, renameArgs.file, renameArgs.findInComments, renameArgs.findInStrings);
+                        response = this.getRenameLocations(<protocol.RenameRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.Open: {
-                        var openArgs = <protocol.OpenRequestArgs>request.arguments;
-                        this.openClientFile(openArgs.file);
+                        this.openClientFile(<protocol.OpenRequestArgs>request.arguments);
                         responseRequired = false;
                         break;
                     }
                     case CommandNames.Quickinfo: {
-                        var quickinfoArgs = <protocol.FileLocationRequestArgs>request.arguments;
-                        response = this.getQuickInfo(quickinfoArgs.line, quickinfoArgs.offset, quickinfoArgs.file);
+                        response = this.getQuickInfo(<protocol.FileLocationRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.Format: {
-                        var formatArgs = <protocol.FormatRequestArgs>request.arguments;
-                        response = this.getFormattingEditsForRange(formatArgs.line, formatArgs.offset, formatArgs.endLine, formatArgs.endOffset, formatArgs.file);
+                        response = this.getFormattingEditsForRange(<protocol.FormatRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.Formatonkey: {
-                        var formatOnKeyArgs = <protocol.FormatOnKeyRequestArgs>request.arguments;
-                        response = this.getFormattingEditsAfterKeystroke(formatOnKeyArgs.line, formatOnKeyArgs.offset, formatOnKeyArgs.key, formatOnKeyArgs.file);
+                        response = this.getFormattingEditsAfterKeystroke(<protocol.FormatOnKeyRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.Completions: {
-                        var completionsArgs = <protocol.CompletionsRequestArgs>request.arguments;
-                        response = this.getCompletions(completionsArgs.line, completionsArgs.offset, completionsArgs.prefix, completionsArgs.file);
+                        response = this.getCompletions(<protocol.CompletionsRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.CompletionDetails: {
-                        var completionDetailsArgs = <protocol.CompletionDetailsRequestArgs>request.arguments;
-                        response =
-                            this.getCompletionEntryDetails(completionDetailsArgs.line,completionDetailsArgs.offset,
-                                                           completionDetailsArgs.entryNames,completionDetailsArgs.file);
+                        response = this.getCompletionEntryDetails(<protocol.CompletionDetailsRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.SignatureHelp: {
-                        var signatureHelpArgs = <protocol.SignatureHelpRequestArgs>request.arguments;
-                        response = this.getSignatureHelpItems(signatureHelpArgs.line, signatureHelpArgs.offset, signatureHelpArgs.file);
+                        response = this.getSignatureHelpItems(<protocol.SignatureHelpRequestArgs>request.arguments);
                         break;
                     }    
                     case CommandNames.Geterr: {
-                        var geterrArgs = <protocol.GeterrRequestArgs>request.arguments;
-                        response = this.getDiagnostics(geterrArgs.delay, geterrArgs.files);
+                        this.getDiagnostics(<protocol.GeterrRequestArgs>request.arguments);
                         responseRequired = false;
                         break;
                     }
                     case CommandNames.Change: {
-                        var changeArgs = <protocol.ChangeRequestArgs>request.arguments;
-                        this.change(changeArgs.line, changeArgs.offset, changeArgs.endLine, changeArgs.endOffset,
-                                    changeArgs.insertString, changeArgs.file);
+                        this.change(<protocol.ChangeRequestArgs>request.arguments);
                         responseRequired = false;
                         break;
                     }
                     case CommandNames.Configure: {
-                        var configureArgs = <protocol.ConfigureRequestArguments>request.arguments;
-                        this.projectService.setHostConfiguration(configureArgs);
+                        this.projectService.setHostConfiguration(<protocol.ConfigureRequestArguments>request.arguments);
                         this.output(undefined, CommandNames.Configure, request.seq);
                         responseRequired = false;
                         break;
                     }
                     case CommandNames.Reload: {
-                        var reloadArgs = <protocol.ReloadRequestArgs>request.arguments;
-                        this.reload(reloadArgs.file, reloadArgs.tmpfile, request.seq);
+                        this.reload(<protocol.ReloadRequestArgs>request.arguments);
                         responseRequired = false;
                         break;
                     }
                     case CommandNames.Saveto: {
-                        var savetoArgs = <protocol.SavetoRequestArgs>request.arguments;
-                        this.saveToTmp(savetoArgs.file, savetoArgs.tmpfile);
+                        this.saveToTmp(<protocol.SavetoRequestArgs>request.arguments);
                         responseRequired = false;
                         break;
                     }
                     case CommandNames.Close: {
-                        var closeArgs = <protocol.FileRequestArgs>request.arguments;
-                        this.closeClientFile(closeArgs.file);
+                        this.closeClientFile(<protocol.FileRequestArgs>request.arguments);
                         responseRequired = false;
                         break;
                     }
                     case CommandNames.Navto: {
-                        var navtoArgs = <protocol.NavtoRequestArgs>request.arguments;
-                        response = this.getNavigateToItems(navtoArgs.searchValue, navtoArgs.file, navtoArgs.maxResultCount);
+                        response = this.getNavigateToItems(<protocol.NavtoRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.Brace: {
-                        var braceArguments = <protocol.FileLocationRequestArgs>request.arguments;
-                        response = this.getBraceMatching(braceArguments.line, braceArguments.offset, braceArguments.file);
+                        response = this.getBraceMatching(<protocol.FileLocationRequestArgs>request.arguments);
                         break;
                     }
                     case CommandNames.NavBar: {
-                        var navBarArgs = <protocol.FileRequestArgs>request.arguments;
-                        response = this.getNavigationBarItems(navBarArgs.file);
+                        response = this.getNavigationBarItems(<protocol.FileRequestArgs>request.arguments);
+                        break;
+                    }
+                    case CommandNames.Occurrences: {
+                        response = this.getOccurrences(<protocol.FileLocationRequestArgs>request.arguments);
                         break;
                     }
                     default: {

src/services/navigateTo.ts

@@ -22,7 +22,7 @@ module ts.NavigateTo {
                         continue;
                     }
 
-                    // It was a match!  If the pattern has dots in it, then also see if hte 
+                    // It was a match!  If the pattern has dots in it, then also see if the 
                     // declaration container matches as well.
                     if (patternMatcher.patternContainsDots) {
                         let containers = getContainers(declaration);

src/services/navigationBar.ts

@@ -418,10 +418,10 @@ module ts.NavigationBar {
             }
 
             function createFunctionItem(node: FunctionDeclaration) {
-                if ((node.name || node.flags & NodeFlags.Default) && node.body && node.body.kind === SyntaxKind.Block) {
+                if (node.body && node.body.kind === SyntaxKind.Block) {
                     let childItems = getItemsWorker(sortNodes((<Block>node.body).statements), createChildItem);
 
-                    return getNavigationBarItem((!node.name && node.flags & NodeFlags.Default) ? "default": node.name.text ,
+                    return getNavigationBarItem(!node.name ? "default": node.name.text ,
                         ts.ScriptElementKind.functionElement,
                         getNodeModifiers(node),
                         [getNodeSpan(node)],
@@ -470,7 +470,7 @@ module ts.NavigationBar {
                     childItems = getItemsWorker(sortNodes(nodes), createChildItem);
                 }
 
-                var nodeName = !node.name && (node.flags & NodeFlags.Default) ? "default" : node.name.text;
+                var nodeName = !node.name ? "default" : node.name.text;
 
                 return getNavigationBarItem(
                     nodeName,

src/services/patternMatcher.ts

@@ -471,7 +471,7 @@ module ts {
 
     // Helper function to compare two matches to determine which is better.  Matches are first
     // ordered by kind (so all prefix matches always beat all substring matches).  Then, if the
-    // match is a camel case match, the relative weights of hte match are used to determine 
+    // match is a camel case match, the relative weights of the match are used to determine 
     // which is better (with a greater weight being better).  Then if the match is of the same 
     // type, then a case sensitive match is considered better than an insensitive one. 
     function patternMatchCompareTo(match1: PatternMatch, match2: PatternMatch): number {

src/services/services.ts

@@ -730,7 +730,7 @@ module ts {
         public statements: NodeArray<Statement>;
         public endOfFileToken: Node;
 
-        public amdDependencies: {name: string; path: string}[];
+        public amdDependencies: { name: string; path: string }[];
         public amdModuleName: string;
         public referencedFiles: FileReference[];
 
@@ -769,126 +769,131 @@ module ts {
 
         public getNamedDeclarations() {
             if (!this.namedDeclarations) {
-                let sourceFile = this;
-                let namedDeclarations: Declaration[] = [];
-
-                forEachChild(sourceFile, function visit(node: Node): void {
-                    switch (node.kind) {
-                        case SyntaxKind.FunctionDeclaration:
-                        case SyntaxKind.MethodDeclaration:
-                        case SyntaxKind.MethodSignature:
-                            let functionDeclaration = <FunctionLikeDeclaration>node;
-
-                            if (functionDeclaration.name && functionDeclaration.name.getFullWidth() > 0) {
-                                let lastDeclaration = namedDeclarations.length > 0 ?
-                                    namedDeclarations[namedDeclarations.length - 1] :
-                                    undefined;
-
-                                // Check whether this declaration belongs to an "overload group".
-                                if (lastDeclaration && functionDeclaration.symbol === lastDeclaration.symbol) {
-                                    // Overwrite the last declaration if it was an overload
-                                    // and this one is an implementation.
-                                    if (functionDeclaration.body && !(<FunctionLikeDeclaration>lastDeclaration).body) {
-                                        namedDeclarations[namedDeclarations.length - 1] = functionDeclaration;
-                                    }
-                                }
-                                else {
-                                    namedDeclarations.push(functionDeclaration);
-                                }
-
-                                forEachChild(node, visit);
-                            }
-                            break;
-
-                        case SyntaxKind.ClassDeclaration:
-                        case SyntaxKind.InterfaceDeclaration:
-                        case SyntaxKind.TypeAliasDeclaration:
-                        case SyntaxKind.EnumDeclaration:
-                        case SyntaxKind.ModuleDeclaration:
-                        case SyntaxKind.ImportEqualsDeclaration:
-                        case SyntaxKind.ExportSpecifier:
-                        case SyntaxKind.ImportSpecifier:
-                        case SyntaxKind.ImportEqualsDeclaration:
-                        case SyntaxKind.ImportClause:
-                        case SyntaxKind.NamespaceImport:
-                        case SyntaxKind.GetAccessor:
-                        case SyntaxKind.SetAccessor:
-                        case SyntaxKind.TypeLiteral:
-                            if ((<Declaration>node).name) {
-                                namedDeclarations.push(<Declaration>node);
-                            }
-                        // fall through
-                        case SyntaxKind.Constructor:
-                        case SyntaxKind.VariableStatement:
-                        case SyntaxKind.VariableDeclarationList:
-                        case SyntaxKind.ObjectBindingPattern:
-                        case SyntaxKind.ArrayBindingPattern:
-                        case SyntaxKind.ModuleBlock:
-                            forEachChild(node, visit);
-                            break;
-
-                        case SyntaxKind.Block:
-                            if (isFunctionBlock(node)) {
-                                forEachChild(node, visit);
-                            }
-                            break;
-
-                        case SyntaxKind.Parameter:
-                            // Only consider properties defined as constructor parameters
-                            if (!(node.flags & NodeFlags.AccessibilityModifier)) {
-                                break;
-                            }
-                        // fall through
-                        case SyntaxKind.VariableDeclaration:
-                        case SyntaxKind.BindingElement:
-                            if (isBindingPattern((<VariableDeclaration>node).name)) {
-                                forEachChild((<VariableDeclaration>node).name, visit);
-                                break;
-                            }
-                        case SyntaxKind.EnumMember:
-                        case SyntaxKind.PropertyDeclaration:
-                        case SyntaxKind.PropertySignature:
-                            namedDeclarations.push(<Declaration>node);
-                            break;
-                        
-                        case SyntaxKind.ExportDeclaration:
-                            // Handle named exports case e.g.:
-                            //    export {a, b as B} from "mod";
-                            if ((<ExportDeclaration>node).exportClause) {
-                                forEach((<ExportDeclaration>node).exportClause.elements, visit);
-                            }
-                            break;
-
-                        case SyntaxKind.ImportDeclaration:
-                            let importClause = (<ImportDeclaration>node).importClause;
-                            if (importClause) {
-                                // Handle default import case e.g.:
-                                //    import d from "mod";
-                                if (importClause.name) {
-                                    namedDeclarations.push(importClause);
-                                }
-
-                                // Handle named bindings in imports e.g.:
-                                //    import * as NS from "mod";
-                                //    import {a, b as B} from "mod";
-                                if (importClause.namedBindings) {
-                                    if (importClause.namedBindings.kind === SyntaxKind.NamespaceImport) {
-                                        namedDeclarations.push(<NamespaceImport>importClause.namedBindings);
-                                    }
-                                    else {
-                                        forEach((<NamedImports>importClause.namedBindings).elements, visit);
-                                    }
-                                }
-                            }
-                            break;
-                    }
-                });
-
-                this.namedDeclarations = namedDeclarations;
+                this.namedDeclarations = this.computeNamedDeclarations();
             }
 
             return this.namedDeclarations;
         }
+
+        private computeNamedDeclarations() {
+            let namedDeclarations: Declaration[] = [];
+
+            forEachChild(this, visit);
+
+            return namedDeclarations;
+
+            function visit(node: Node): void {
+                switch (node.kind) {
+                    case SyntaxKind.FunctionDeclaration:
+                    case SyntaxKind.MethodDeclaration:
+                    case SyntaxKind.MethodSignature:
+                        let functionDeclaration = <FunctionLikeDeclaration>node;
+
+                        if (functionDeclaration.name && functionDeclaration.name.getFullWidth() > 0) {
+                            let lastDeclaration = namedDeclarations.length > 0 ?
+                                namedDeclarations[namedDeclarations.length - 1] :
+                                undefined;
+
+                            // Check whether this declaration belongs to an "overload group".
+                            if (lastDeclaration && functionDeclaration.symbol === lastDeclaration.symbol) {
+                                // Overwrite the last declaration if it was an overload
+                                // and this one is an implementation.
+                                if (functionDeclaration.body && !(<FunctionLikeDeclaration>lastDeclaration).body) {
+                                    namedDeclarations[namedDeclarations.length - 1] = functionDeclaration;
+                                }
+                            }
+                            else {
+                                namedDeclarations.push(functionDeclaration);
+                            }
+
+                            forEachChild(node, visit);
+                        }
+                        break;
+
+                    case SyntaxKind.ClassDeclaration:
+                    case SyntaxKind.InterfaceDeclaration:
+                    case SyntaxKind.TypeAliasDeclaration:
+                    case SyntaxKind.EnumDeclaration:
+                    case SyntaxKind.ModuleDeclaration:
+                    case SyntaxKind.ImportEqualsDeclaration:
+                    case SyntaxKind.ExportSpecifier:
+                    case SyntaxKind.ImportSpecifier:
+                    case SyntaxKind.ImportEqualsDeclaration:
+                    case SyntaxKind.ImportClause:
+                    case SyntaxKind.NamespaceImport:
+                    case SyntaxKind.GetAccessor:
+                    case SyntaxKind.SetAccessor:
+                    case SyntaxKind.TypeLiteral:
+                        if ((<Declaration>node).name) {
+                            namedDeclarations.push(<Declaration>node);
+                        }
+                    // fall through
+                    case SyntaxKind.Constructor:
+                    case SyntaxKind.VariableStatement:
+                    case SyntaxKind.VariableDeclarationList:
+                    case SyntaxKind.ObjectBindingPattern:
+                    case SyntaxKind.ArrayBindingPattern:
+                    case SyntaxKind.ModuleBlock:
+                        forEachChild(node, visit);
+                        break;
+
+                    case SyntaxKind.Block:
+                        if (isFunctionBlock(node)) {
+                            forEachChild(node, visit);
+                        }
+                        break;
+
+                    case SyntaxKind.Parameter:
+                        // Only consider properties defined as constructor parameters
+                        if (!(node.flags & NodeFlags.AccessibilityModifier)) {
+                            break;
+                        }
+                    // fall through
+                    case SyntaxKind.VariableDeclaration:
+                    case SyntaxKind.BindingElement:
+                        if (isBindingPattern((<VariableDeclaration>node).name)) {
+                            forEachChild((<VariableDeclaration>node).name, visit);
+                            break;
+                        }
+                    case SyntaxKind.EnumMember:
+                    case SyntaxKind.PropertyDeclaration:
+                    case SyntaxKind.PropertySignature:
+                        namedDeclarations.push(<Declaration>node);
+                        break;
+
+                    case SyntaxKind.ExportDeclaration:
+                        // Handle named exports case e.g.:
+                        //    export {a, b as B} from "mod";
+                        if ((<ExportDeclaration>node).exportClause) {
+                            forEach((<ExportDeclaration>node).exportClause.elements, visit);
+                        }
+                        break;
+
+                    case SyntaxKind.ImportDeclaration:
+                        let importClause = (<ImportDeclaration>node).importClause;
+                        if (importClause) {
+                            // Handle default import case e.g.:
+                            //    import d from "mod";
+                            if (importClause.name) {
+                                namedDeclarations.push(importClause);
+                            }
+
+                            // Handle named bindings in imports e.g.:
+                            //    import * as NS from "mod";
+                            //    import {a, b as B} from "mod";
+                            if (importClause.namedBindings) {
+                                if (importClause.namedBindings.kind === SyntaxKind.NamespaceImport) {
+                                    namedDeclarations.push(<NamespaceImport>importClause.namedBindings);
+                                }
+                                else {
+                                    forEach((<NamedImports>importClause.namedBindings).elements, visit);
+                                }
+                            }
+                        }
+                        break;
+                }
+            }
+        }
     }
 
     //
@@ -1143,6 +1148,7 @@ module ts {
         name: string;
         kind: string;            // see ScriptElementKind
         kindModifiers: string;   // see ScriptElementKindModifier, comma separated
+        sortText: string;
     }
 
     export interface CompletionEntryDetails {
@@ -1311,6 +1317,7 @@ module ts {
     // TODO: move these to enums
     export class ScriptElementKind {
         static unknown = "";
+        static warning = "warning";
 
         // predefined type (void) or keyword (class)
         static keyword = "keyword";
@@ -1673,7 +1680,7 @@ module ts {
             useCaseSensitiveFileNames: () => false,
             getCanonicalFileName: fileName => fileName,
             getCurrentDirectory: () => "",
-            getNewLine: () => "\r\n"
+            getNewLine: () => (sys && sys.newLine) || "\r\n"
         };
 
         var program = createProgram([inputFileName], options, compilerHost);
@@ -2161,7 +2168,8 @@ module ts {
         keywordCompletions.push({
             name: tokenToString(i),
             kind: ScriptElementKind.keyword,
-            kindModifiers: ScriptElementKindModifier.none
+            kindModifiers: ScriptElementKindModifier.none,
+            sortText: "0"
         });
     }
 
@@ -2425,15 +2433,26 @@ module ts {
             return program.getSyntacticDiagnostics(getValidSourceFile(fileName));
         }
 
+        function isJavaScript(fileName: string) {
+            return fileExtensionIs(fileName, ".js");
+        }
+
         /**
          * getSemanticDiagnostiscs return array of Diagnostics. If '-d' is not enabled, only report semantic errors
          * If '-d' enabled, report both semantic and emitter errors  
          */
-        function getSemanticDiagnostics(fileName: string) {
+        function getSemanticDiagnostics(fileName: string): Diagnostic[] {
             synchronizeHostData();
 
             let targetSourceFile = getValidSourceFile(fileName);
 
+            // For JavaScript files, we don't want to report the normal typescript semantic errors.
+            // Instead, we just report errors for using TypeScript-only constructs from within a 
+            // JavaScript file.
+            if (isJavaScript(fileName)) {
+                return getJavaScriptSemanticDiagnostics(targetSourceFile);
+            }
+
             // Only perform the action per file regardless of '-out' flag as LanguageServiceHost is expected to call this function per file.
             // Therefore only get diagnostics for given file.
 
@@ -2447,35 +2466,199 @@ module ts {
             return concatenate(semanticDiagnostics, declarationDiagnostics);
         }
 
+        function getJavaScriptSemanticDiagnostics(sourceFile: SourceFile): Diagnostic[] {
+            let diagnostics: Diagnostic[] = [];
+            walk(sourceFile);
+
+            return diagnostics;
+
+            function walk(node: Node): boolean {
+                if (!node) {
+                    return false;
+                }
+
+                switch (node.kind) {
+                    case SyntaxKind.ImportEqualsDeclaration:
+                        diagnostics.push(createDiagnosticForNode(node, Diagnostics.import_can_only_be_used_in_a_ts_file));
+                        return true;
+                    case SyntaxKind.ExportAssignment:
+                        diagnostics.push(createDiagnosticForNode(node, Diagnostics.export_can_only_be_used_in_a_ts_file));
+                        return true;
+                    case SyntaxKind.ClassDeclaration:
+                        let classDeclaration = <ClassDeclaration>node;
+                        if (checkModifiers(classDeclaration.modifiers) ||
+                            checkTypeParameters(classDeclaration.typeParameters)) {
+                            return true;
+                        }
+                        break;
+                    case SyntaxKind.HeritageClause:
+                        let heritageClause = <HeritageClause>node;
+                        if (heritageClause.token === SyntaxKind.ImplementsKeyword) {
+                            diagnostics.push(createDiagnosticForNode(node, Diagnostics.implements_clauses_can_only_be_used_in_a_ts_file));
+                            return true;
+                        }
+                        break;
+                    case SyntaxKind.InterfaceDeclaration:
+                        diagnostics.push(createDiagnosticForNode(node, Diagnostics.interface_declarations_can_only_be_used_in_a_ts_file));
+                        return true;
+                    case SyntaxKind.ModuleDeclaration:
+                        diagnostics.push(createDiagnosticForNode(node, Diagnostics.module_declarations_can_only_be_used_in_a_ts_file));
+                        return true;
+                    case SyntaxKind.TypeAliasDeclaration:
+                        diagnostics.push(createDiagnosticForNode(node, Diagnostics.type_aliases_can_only_be_used_in_a_ts_file));
+                        return true;
+                    case SyntaxKind.MethodDeclaration:
+                    case SyntaxKind.MethodSignature:
+                    case SyntaxKind.Constructor:
+                    case SyntaxKind.GetAccessor:
+                    case SyntaxKind.SetAccessor:
+                    case SyntaxKind.FunctionExpression:
+                    case SyntaxKind.FunctionDeclaration:
+                    case SyntaxKind.ArrowFunction:
+                    case SyntaxKind.FunctionDeclaration:
+                        let functionDeclaration = <FunctionLikeDeclaration>node;
+                        if (checkModifiers(functionDeclaration.modifiers) ||
+                            checkTypeParameters(functionDeclaration.typeParameters) ||
+                            checkTypeAnnotation(functionDeclaration.type)) {
+                            return true;
+                        }
+                        break;
+                    case SyntaxKind.VariableStatement:
+                        let variableStatement = <VariableStatement>node;
+                        if (checkModifiers(variableStatement.modifiers)) {
+                            return true;
+                        }
+                        break;
+                    case SyntaxKind.VariableDeclaration:
+                        let variableDeclaration = <VariableDeclaration>node;
+                        if (checkTypeAnnotation(variableDeclaration.type)) {
+                            return true;
+                        }
+                        break;
+                    case SyntaxKind.CallExpression:
+                    case SyntaxKind.NewExpression:
+                        let expression = <CallExpression>node;
+                        if (expression.typeArguments && expression.typeArguments.length > 0) {
+                            let start = expression.typeArguments.pos;
+                            diagnostics.push(createFileDiagnostic(sourceFile, start, expression.typeArguments.end - start,
+                                Diagnostics.type_arguments_can_only_be_used_in_a_ts_file));
+                            return true;
+                        }
+                        break;
+                    case SyntaxKind.Parameter:
+                        let parameter = <ParameterDeclaration>node;
+                        if (parameter.modifiers) {
+                            let start = parameter.modifiers.pos;
+                            diagnostics.push(createFileDiagnostic(sourceFile, start, parameter.modifiers.end - start,
+                                Diagnostics.parameter_modifiers_can_only_be_used_in_a_ts_file));
+                            return true;
+                        }
+                        if (parameter.questionToken) {
+                            diagnostics.push(createDiagnosticForNode(parameter.questionToken, Diagnostics.can_only_be_used_in_a_ts_file));
+                            return true;
+                        }
+                        if (parameter.type) {
+                            diagnostics.push(createDiagnosticForNode(parameter.type, Diagnostics.types_can_only_be_used_in_a_ts_file));
+                            return true;
+                        }
+                        break;
+                    case SyntaxKind.PropertyDeclaration:
+                        diagnostics.push(createDiagnosticForNode(node, Diagnostics.property_declarations_can_only_be_used_in_a_ts_file));
+                        return true;
+                    case SyntaxKind.EnumDeclaration:
+                        diagnostics.push(createDiagnosticForNode(node, Diagnostics.enum_declarations_can_only_be_used_in_a_ts_file));
+                        return true;
+                    case SyntaxKind.TypeAssertionExpression:
+                        let typeAssertionExpression = <TypeAssertion>node;
+                        diagnostics.push(createDiagnosticForNode(typeAssertionExpression.type, Diagnostics.type_assertion_expressions_can_only_be_used_in_a_ts_file));
+                        return true;
+                    case SyntaxKind.Decorator:
+                        diagnostics.push(createDiagnosticForNode(node, Diagnostics.decorators_can_only_be_used_in_a_ts_file));
+                        return true;
+                }
+
+                return forEachChild(node, walk);
+            }
+
+            function checkTypeParameters(typeParameters: NodeArray<TypeParameterDeclaration>): boolean {
+                if (typeParameters) {
+                    let start = typeParameters.pos;
+                    diagnostics.push(createFileDiagnostic(sourceFile, start, typeParameters.end - start, Diagnostics.type_parameter_declarations_can_only_be_used_in_a_ts_file));
+                    return true;
+                }
+                return false;
+            }
+
+            function checkTypeAnnotation(type: TypeNode): boolean {
+                if (type) {
+                    diagnostics.push(createDiagnosticForNode(type, Diagnostics.types_can_only_be_used_in_a_ts_file));
+                    return true;
+                }
+
+                return false;
+            }
+
+            function checkModifiers(modifiers: ModifiersArray): boolean {
+                if (modifiers) {
+                    for (let modifier of modifiers) {
+                        switch (modifier.kind) {
+                            case SyntaxKind.PublicKeyword:
+                            case SyntaxKind.PrivateKeyword:
+                            case SyntaxKind.ProtectedKeyword:
+                            case SyntaxKind.DeclareKeyword:
+                                diagnostics.push(createDiagnosticForNode(modifier, Diagnostics._0_can_only_be_used_in_a_ts_file, tokenToString(modifier.kind)));
+                                return true;
+
+                            // These are all legal modifiers.
+                            case SyntaxKind.StaticKeyword:
+                            case SyntaxKind.ExportKeyword:
+                            case SyntaxKind.ConstKeyword:
+                            case SyntaxKind.DefaultKeyword:
+                        }
+                    }
+                }
+
+                return false;
+            }
+        }
+
         function getCompilerOptionsDiagnostics() {
             synchronizeHostData();
             return program.getGlobalDiagnostics();
         }
 
         /// Completion
-        function getCompletionEntryDisplayName(symbol: Symbol, target: ScriptTarget, performCharacterChecks: boolean): string {
+        function getCompletionEntryDisplayNameForSymbol(symbol: Symbol, target: ScriptTarget, performCharacterChecks: boolean): string {
             let displayName = symbol.getName();
+            if (displayName) {
+                // If this is the default export, get the name of the declaration if it exists
+                if (displayName === "default") {
+                    let localSymbol = getLocalSymbolForExportDefault(symbol);
+                    if (localSymbol && localSymbol.name) {
+                        displayName = symbol.valueDeclaration.localSymbol.name;
+                    }
+                }
+
+                let firstCharCode = displayName.charCodeAt(0);
+                // First check of the displayName is not external module; if it is an external module, it is not valid entry
+                if ((symbol.flags & SymbolFlags.Namespace) && (firstCharCode === CharacterCodes.singleQuote || firstCharCode === CharacterCodes.doubleQuote)) {
+                    // If the symbol is external module, don't show it in the completion list
+                    // (i.e declare module "http" { let x; } | // <= request completion here, "http" should not be there)
+                    return undefined;
+                }
+            }
+
+            return getCompletionEntryDisplayName(displayName, target, performCharacterChecks);
+        }
+
+        function getCompletionEntryDisplayName(displayName: string, target: ScriptTarget, performCharacterChecks: boolean): string {
             if (!displayName) {
                 return undefined;
             }
 
-            // If this is the default export, get the name of the declaration if it exists
-            if (displayName === "default") {
-                let localSymbol = getLocalSymbolForExportDefault(symbol);
-                if (localSymbol && localSymbol.name) {
-                    displayName = symbol.valueDeclaration.localSymbol.name;
-                }
-            }
-
             let firstCharCode = displayName.charCodeAt(0);
-            // First check of the displayName is not external module; if it is an external module, it is not valid entry
-            if ((symbol.flags & SymbolFlags.Namespace) && (firstCharCode === CharacterCodes.singleQuote || firstCharCode === CharacterCodes.doubleQuote)) {
-                // If the symbol is external module, don't show it in the completion list
-                // (i.e declare module "http" { let x; } | // <= request completion here, "http" should not be there)
-                return undefined;
-            }
-
-            if (displayName && displayName.length >= 2 && firstCharCode === displayName.charCodeAt(displayName.length - 1) &&
+            if (displayName.length >= 2 &&
+                firstCharCode === displayName.charCodeAt(displayName.length - 1) &&
                 (firstCharCode === CharacterCodes.singleQuote || firstCharCode === CharacterCodes.doubleQuote)) {
                 // If the user entered name for the symbol was quoted, removing the quotes is not enough, as the name could be an
                 // invalid identifier name. We need to check if whatever was inside the quotes is actually a valid identifier name.
@@ -2505,19 +2688,24 @@ module ts {
             // Try to get a valid display name for this symbol, if we could not find one, then ignore it. 
             // We would like to only show things that can be added after a dot, so for instance numeric properties can
             // not be accessed with a dot (a.1 <- invalid)
-            let displayName = getCompletionEntryDisplayName(symbol, program.getCompilerOptions().target, /*performCharacterChecks:*/ true);
+            let displayName = getCompletionEntryDisplayNameForSymbol(symbol, program.getCompilerOptions().target, /*performCharacterChecks:*/ true);
             if (!displayName) {
                 return undefined;
             }
 
-            // TODO(drosen): Right now we just permit *all* semantic meanings when calling 'getSymbolKind'
-            //               which is permissible given that it is backwards compatible; but really we should consider
-            //               passing the meaning for the node so that we don't report that a suggestion for a value is an interface.
-            //               We COULD also just do what 'getSymbolModifiers' does, which is to use the first declaration.
+            // TODO(drosen): Right now we just permit *all* semantic meanings when calling 
+            // 'getSymbolKind' which is permissible given that it is backwards compatible; but 
+            // really we should consider passing the meaning for the node so that we don't report
+            // that a suggestion for a value is an interface.  We COULD also just do what 
+            // 'getSymbolModifiers' does, which is to use the first declaration.
+
+            // Use a 'sortText' of 0' so that all symbol completion entries come before any other
+            // entries (like JavaScript identifier entries).
             return {
                 name: displayName,
                 kind: getSymbolKind(symbol, typeChecker, location),
-                kindModifiers: getSymbolModifiers(symbol)
+                kindModifiers: getSymbolModifiers(symbol),
+                sortText: "0",
             };
         }
 
@@ -2561,8 +2749,9 @@ module ts {
                 return undefined;
             }
 
-            // Find the node where completion is requested on, in the case of a completion after a dot, it is the member access expression
-            // otherwise, it is a request for all visible symbols in the scope, and the node is the current location
+            // Find the node where completion is requested on, in the case of a completion after 
+            // a dot, it is the member access expression other wise, it is a request for all 
+            // visible symbols in the scope, and the node is the current location.
             let node = currentToken;
             let isRightOfDot = false;
             if (contextToken && contextToken.kind === SyntaxKind.DotToken && contextToken.parent.kind === SyntaxKind.PropertyAccessExpression) {
@@ -2580,11 +2769,26 @@ module ts {
             let semanticStart = new Date().getTime();
             let isMemberCompletion: boolean;
             let isNewIdentifierLocation: boolean;
-            let symbols: Symbol[];
+            let symbols: Symbol[] = [];
 
             if (isRightOfDot) {
+                getTypeScriptMemberSymbols();
+            }
+            else {
+                // For JavaScript or TypeScript, if we're not after a dot, then just try to get the
+                // global symbols in scope.  These results should be valid for either language as
+                // the set of symbols that can be referenced from this location.
+                if (!tryGetGlobalSymbols()) {
+                    return undefined;
+                }
+            }
+
+            log("getCompletionData: Semantic work: " + (new Date().getTime() - semanticStart));
+
+            return { symbols, isMemberCompletion, isNewIdentifierLocation, location, isRightOfDot };
+
+            function getTypeScriptMemberSymbols(): void {
                 // Right of dot member completion list
-                symbols = [];
                 isMemberCompletion = true;
                 isNewIdentifierLocation = false;
 
@@ -2598,7 +2802,8 @@ module ts {
 
                     if (symbol && symbol.flags & SymbolFlags.HasExports) {
                         // Extract module or enum members
-                        forEachValue(symbol.exports, symbol => {
+                        let exportedSymbols = typeInfoResolver.getExportsOfModule(symbol);
+                        forEach(exportedSymbols, symbol => {
                             if (typeInfoResolver.isValidPropertyAccess(<PropertyAccessExpression>(node.parent), symbol.name)) {
                                 symbols.push(symbol);
                             }
@@ -2616,7 +2821,8 @@ module ts {
                     });
                 }
             }
-            else {
+
+            function tryGetGlobalSymbols(): boolean {
                 let containingObjectLiteral = getContainingObjectLiteralApplicableForCompletion(contextToken);
                 if (containingObjectLiteral) {
                     // Object literal expression, look up possible property names from contextual type
@@ -2625,7 +2831,7 @@ module ts {
 
                     let contextualType = typeInfoResolver.getContextualType(containingObjectLiteral);
                     if (!contextualType) {
-                        return undefined;
+                        return false;
                     }
 
                     let contextualTypeMembers = typeInfoResolver.getPropertiesOfType(contextualType);
@@ -2642,8 +2848,17 @@ module ts {
                     if (showCompletionsInImportsClause(contextToken)) {
                         let importDeclaration = <ImportDeclaration>getAncestor(contextToken, SyntaxKind.ImportDeclaration);
                         Debug.assert(importDeclaration !== undefined);
-                        let exports = typeInfoResolver.getExportsOfExternalModule(importDeclaration);
-                        symbols = filterModuleExports(exports, importDeclaration);
+
+                        let exports: Symbol[];
+                        if (importDeclaration.moduleSpecifier) {
+                            let moduleSpecifierSymbol = typeInfoResolver.getSymbolAtLocation(importDeclaration.moduleSpecifier);
+                            if (moduleSpecifierSymbol) {
+                                exports = typeInfoResolver.getExportsOfModule(moduleSpecifierSymbol);
+                            }
+                        }
+
+                        //let exports = typeInfoResolver.getExportsOfImportDeclaration(importDeclaration);
+                        symbols = exports ? filterModuleExports(exports, importDeclaration) : emptyArray;
                     }
                 }
                 else {
@@ -2689,12 +2904,10 @@ module ts {
                     let symbolMeanings = SymbolFlags.Type | SymbolFlags.Value | SymbolFlags.Namespace | SymbolFlags.Alias;
                     symbols = typeInfoResolver.getSymbolsInScope(scopeNode, symbolMeanings);
                 }
+
+                return true;
             }
 
-            log("getCompletionData: Semantic work: " + (new Date().getTime() - semanticStart));
-
-            return { symbols, isMemberCompletion, isNewIdentifierLocation, location };
-
             /**
              * Finds the first node that "embraces" the position, so that one may
              * accurately aggregate locals from the closest containing scope.
@@ -3001,12 +3214,20 @@ module ts {
                 return undefined;
             }
 
-            let { symbols, isMemberCompletion, isNewIdentifierLocation, location } = completionData;
-            if (!symbols || symbols.length === 0) {
-                return undefined;
-            }
+            let { symbols, isMemberCompletion, isNewIdentifierLocation, location, isRightOfDot } = completionData;
 
-            var entries = getCompletionEntriesFromSymbols(symbols);
+            let entries: CompletionEntry[];
+            if (isRightOfDot && isJavaScript(fileName)) {
+                entries = getCompletionEntriesFromSymbols(symbols);
+                addRange(entries, getJavaScriptCompletionEntries());
+            }
+            else {
+                if (!symbols || symbols.length === 0) {
+                    return undefined;
+                }
+
+                entries = getCompletionEntriesFromSymbols(symbols);
+            }
 
             // Add keywords if this is not a member completion list
             if (!isMemberCompletion) {
@@ -3015,21 +3236,51 @@ module ts {
 
             return { isMemberCompletion, isNewIdentifierLocation, entries };
 
-            function getCompletionEntriesFromSymbols(symbols: Symbol[]): CompletionEntry[] {
-                let start = new Date().getTime();
-                var entries: CompletionEntry[] = [];
-                var nameToSymbol: Map<Symbol> = {};
+            function getJavaScriptCompletionEntries(): CompletionEntry[] {
+                let entries: CompletionEntry[] = [];
+                let allNames: Map<string> = {};
+                let target = program.getCompilerOptions().target;
 
-                for (let symbol of symbols) {
-                    let entry = createCompletionEntry(symbol, typeInfoResolver, location);
-                    if (entry) {
-                        let id = escapeIdentifier(entry.name);
-                        if (!lookUp(nameToSymbol, id)) {
-                            entries.push(entry);
-                            nameToSymbol[id] = symbol;
+                for (let sourceFile of program.getSourceFiles()) {
+                    let nameTable = getNameTable(sourceFile);
+                    for (let name in nameTable) {
+                        if (!allNames[name]) {
+                            allNames[name] = name;
+                            let displayName = getCompletionEntryDisplayName(name, target, /*performCharacterChecks:*/ true);
+                            if (displayName) {
+                                let entry = {
+                                    name: displayName,
+                                    kind: ScriptElementKind.warning,
+                                    kindModifiers: "",
+                                    sortText: "1"
+                                };
+                                entries.push(entry);
+                            }
                         }
                     }
                 }
+
+                return entries;
+            }
+
+            function getCompletionEntriesFromSymbols(symbols: Symbol[]): CompletionEntry[] {
+                let start = new Date().getTime();
+                var entries: CompletionEntry[] = [];
+
+                if (symbols) {
+                    var nameToSymbol: Map<Symbol> = {};
+                    for (let symbol of symbols) {
+                        let entry = createCompletionEntry(symbol, typeInfoResolver, location);
+                        if (entry) {
+                            let id = escapeIdentifier(entry.name);
+                            if (!lookUp(nameToSymbol, id)) {
+                                entries.push(entry);
+                                nameToSymbol[id] = symbol;
+                            }
+                        }
+                    }
+                }
+
                 log("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (new Date().getTime() - start));
                 return entries;
             }
@@ -3048,7 +3299,7 @@ module ts {
                 // We don't need to perform character checks here because we're only comparing the 
                 // name against 'entryName' (which is known to be good), not building a new 
                 // completion entry.
-                let symbol = forEach(symbols, s => getCompletionEntryDisplayName(s, target, /*performCharacterChecks:*/ false) === entryName ? s : undefined);
+                let symbol = forEach(symbols, s => getCompletionEntryDisplayNameForSymbol(s, target, /*performCharacterChecks:*/ false) === entryName ? s : undefined);
 
                 if (symbol) {
                     let displayPartsDocumentationsAndSymbolKind = getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, getValidSourceFile(fileName), location, typeInfoResolver, location, SemanticMeaning.All);

src/services/shims.ts

@@ -331,6 +331,22 @@ module ts {
         }
     }
 
+    /* @internal */
+    export function realizeDiagnostics(diagnostics: Diagnostic[], newLine: string): { message: string; start: number; length: number; category: string; } []{
+        return diagnostics.map(d => realizeDiagnostic(d, newLine));
+    }
+
+    function realizeDiagnostic(diagnostic: Diagnostic, newLine: string): { message: string; start: number; length: number; category: string; } {
+        return {
+            message: flattenDiagnosticMessageText(diagnostic.messageText, newLine),
+            start: diagnostic.start,
+            length: diagnostic.length,
+            /// TODO: no need for the tolowerCase call
+            category: DiagnosticCategory[diagnostic.category].toLowerCase(),
+            code: diagnostic.code
+        };
+    }
+
     class LanguageServiceShimObject extends ShimBase implements LanguageServiceShim {
         private logger: Logger;
 
@@ -391,18 +407,7 @@ module ts {
 
         private realizeDiagnostics(diagnostics: Diagnostic[]): { message: string; start: number; length: number; category: string; }[]{
             var newLine = this.getNewLine();
-            return diagnostics.map(d => this.realizeDiagnostic(d, newLine));
-        }
-
-        private realizeDiagnostic(diagnostic: Diagnostic, newLine: string): { message: string; start: number; length: number; category: string; } {
-            return {
-                message: flattenDiagnosticMessageText(diagnostic.messageText, newLine),
-                start: diagnostic.start,
-                length: diagnostic.length,
-                /// TODO: no need for the tolowerCase call
-                category: DiagnosticCategory[diagnostic.category].toLowerCase(),
-                code: diagnostic.code
-            };
+            return ts.realizeDiagnostics(diagnostics, newLine);
         }
 
         public getSyntacticClassifications(fileName: string, start: number, length: number): string {

tests/baselines/reference/ES5For-of30.errors.txt

@@ -1,12 +1,18 @@
 tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,6): error TS2461: Type 'string | number' is not an array type.
+tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,7): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,14): error TS2322: Type 'string' is not assignable to type 'number'.
 
 
-==== tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts (1 errors) ====
+==== tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts (3 errors) ====
     var a: string, b: number;
     var tuple: [number, string] = [2, "3"];
     for ([a = 1, b = ""] of tuple) {
          ~~~~~~~~~~~~~~~
 !!! error TS2461: Type 'string | number' is not an array type.
+          ~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+                 ~
+!!! error TS2322: Type 'string' is not assignable to type 'number'.
         a;
         b;
     }

tests/baselines/reference/ES5SymbolProperty1.js

@@ -14,6 +14,7 @@ obj[Symbol.foo];
 var Symbol;
 var obj = (_a = {},
     _a[Symbol.foo] = 0,
-    _a);
+    _a
+);
 obj[Symbol.foo];
 var _a;

tests/baselines/reference/FunctionDeclaration8_es6.js

@@ -2,7 +2,5 @@
 var v = { [yield]: foo }
 
 //// [FunctionDeclaration8_es6.js]
-var v = (_a = {},
-    _a[yield] = foo,
-    _a);
+var v = (_a = {}, _a[yield] = foo, _a);
 var _a;

tests/baselines/reference/FunctionDeclaration9_es6.js

@@ -5,8 +5,6 @@ function * foo() {
 
 //// [FunctionDeclaration9_es6.js]
 function foo() {
-    var v = (_a = {},
-        _a[] = foo,
-        _a);
+    var v = (_a = {}, _a[] = foo, _a);
     var _a;
 }

tests/baselines/reference/FunctionPropertyAssignments5_es6.js

@@ -2,7 +2,5 @@
 var v = { *[foo()]() { } }
 
 //// [FunctionPropertyAssignments5_es6.js]
-var v = (_a = {},
-    _a[foo()] = function () { },
-    _a);
+var v = (_a = {}, _a[foo()] = function () { }, _a);
 var _a;

tests/baselines/reference/anonymousClassExpression1.errors.txt

@@ -0,0 +1,9 @@
+tests/cases/compiler/anonymousClassExpression1.ts(2,19): error TS9003: 'class' expressions are not currently supported.
+
+
+==== tests/cases/compiler/anonymousClassExpression1.ts (1 errors) ====
+    function f() {
+        return typeof class {} === "function";
+                      ~~~~~
+!!! error TS9003: 'class' expressions are not currently supported.
+    }

tests/baselines/reference/anonymousClassExpression1.js

@@ -0,0 +1,13 @@
+//// [anonymousClassExpression1.ts]
+function f() {
+    return typeof class {} === "function";
+}
+
+//// [anonymousClassExpression1.js]
+function f() {
+    return typeof (function () {
+        function default_1() {
+        }
+        return default_1;
+    })() === "function";
+}

tests/baselines/reference/arrayBindingPatternOmittedExpressions.js

@@ -0,0 +1,31 @@
+//// [arrayBindingPatternOmittedExpressions.ts]
+
+var results: string[];
+
+{
+    let [, b, , a] = results;
+    let x = {
+        a,
+        b
+    }
+}
+
+
+function f([, a, , b, , , , s, , , ] = results) {
+    a = s[1];
+    b = s[2];
+}
+
+//// [arrayBindingPatternOmittedExpressions.js]
+var results;
+{
+    let [, b, , a] = results;
+    let x = {
+        a,
+        b
+    };
+}
+function f([, a, , b, , , , s, , ,] = results) {
+    a = s[1];
+    b = s[2];
+}

tests/baselines/reference/arrayBindingPatternOmittedExpressions.types

@@ -0,0 +1,43 @@
+=== tests/cases/compiler/arrayBindingPatternOmittedExpressions.ts ===
+
+var results: string[];
+>results : string[]
+
+{
+    let [, b, , a] = results;
+>b : string
+>a : string
+>results : string[]
+
+    let x = {
+>x : { a: string; b: string; }
+>{        a,        b    } : { a: string; b: string; }
+
+        a,
+>a : string
+
+        b
+>b : string
+    }
+}
+
+
+function f([, a, , b, , , , s, , , ] = results) {
+>f : ([, a, , b, , , , s, , , ]?: string[]) => void
+>a : string
+>b : string
+>s : string
+>results : string[]
+
+    a = s[1];
+>a = s[1] : string
+>a : string
+>s[1] : string
+>s : string
+
+    b = s[2];
+>b = s[2] : string
+>b : string
+>s[2] : string
+>s : string
+}

tests/baselines/reference/arrayLiteralSpread.types

@@ -9,44 +9,55 @@ function f0() {
     var a1 = [...a];
 >a1 : number[]
 >[...a] : number[]
+>...a : number
 >a : number[]
 
     var a2 = [1, ...a];
 >a2 : number[]
 >[1, ...a] : number[]
+>...a : number
 >a : number[]
 
     var a3 = [1, 2, ...a];
 >a3 : number[]
 >[1, 2, ...a] : number[]
+>...a : number
 >a : number[]
 
     var a4 = [...a, 1];
 >a4 : number[]
 >[...a, 1] : number[]
+>...a : number
 >a : number[]
 
     var a5 = [...a, 1, 2];
 >a5 : number[]
 >[...a, 1, 2] : number[]
+>...a : number
 >a : number[]
 
     var a6 = [1, 2, ...a, 1, 2];
 >a6 : number[]
 >[1, 2, ...a, 1, 2] : number[]
+>...a : number
 >a : number[]
 
     var a7 = [1, ...a, 2, ...a];
 >a7 : number[]
 >[1, ...a, 2, ...a] : number[]
+>...a : number
 >a : number[]
+>...a : number
 >a : number[]
 
     var a8 = [...a, ...a, ...a];
 >a8 : number[]
 >[...a, ...a, ...a] : number[]
+>...a : number
 >a : number[]
+>...a : number
 >a : number[]
+>...a : number
 >a : number[]
 }
 
@@ -60,6 +71,7 @@ function f1() {
     var b = ["hello", ...a, true];
 >b : (string | number | boolean)[]
 >["hello", ...a, true] : (string | number | boolean)[]
+>...a : number
 >a : number[]
 
     var b: (string | number | boolean)[];
@@ -72,19 +84,29 @@ function f2() {
     var a = [...[...[...[...[...[]]]]]];
 >a : any[]
 >[...[...[...[...[...[]]]]]] : undefined[]
+>...[...[...[...[...[]]]]] : undefined
 >[...[...[...[...[]]]]] : undefined[]
+>...[...[...[...[]]]] : undefined
 >[...[...[...[]]]] : undefined[]
+>...[...[...[]]] : undefined
 >[...[...[]]] : undefined[]
+>...[...[]] : undefined
 >[...[]] : undefined[]
+>...[] : undefined
 >[] : undefined[]
 
     var b = [...[...[...[...[...[5]]]]]];
 >b : number[]
 >[...[...[...[...[...[5]]]]]] : number[]
+>...[...[...[...[...[5]]]]] : number
 >[...[...[...[...[5]]]]] : number[]
+>...[...[...[...[5]]]] : number
 >[...[...[...[5]]]] : number[]
+>...[...[...[5]]] : number
 >[...[...[5]]] : number[]
+>...[...[5]] : number
 >[...[5]] : number[]
+>...[5] : number
 >[5] : number[]
 }
 

tests/baselines/reference/callWithSpreadES6.types

@@ -38,11 +38,13 @@ foo(1, 2, "abc");
 foo(1, 2, ...a);
 >foo(1, 2, ...a) : void
 >foo : (x: number, y: number, ...z: string[]) => void
+>...a : string
 >a : string[]
 
 foo(1, 2, ...a, "abc");
 >foo(1, 2, ...a, "abc") : void
 >foo : (x: number, y: number, ...z: string[]) => void
+>...a : string
 >a : string[]
 
 obj.foo(1, 2, "abc");
@@ -56,6 +58,7 @@ obj.foo(1, 2, ...a);
 >obj.foo : (x: number, y: number, ...z: string[]) => any
 >obj : X
 >foo : (x: number, y: number, ...z: string[]) => any
+>...a : string
 >a : string[]
 
 obj.foo(1, 2, ...a, "abc");
@@ -63,6 +66,7 @@ obj.foo(1, 2, ...a, "abc");
 >obj.foo : (x: number, y: number, ...z: string[]) => any
 >obj : X
 >foo : (x: number, y: number, ...z: string[]) => any
+>...a : string
 >a : string[]
 
 (obj.foo)(1, 2, "abc");
@@ -78,6 +82,7 @@ obj.foo(1, 2, ...a, "abc");
 >obj.foo : (x: number, y: number, ...z: string[]) => any
 >obj : X
 >foo : (x: number, y: number, ...z: string[]) => any
+>...a : string
 >a : string[]
 
 (obj.foo)(1, 2, ...a, "abc");
@@ -86,6 +91,7 @@ obj.foo(1, 2, ...a, "abc");
 >obj.foo : (x: number, y: number, ...z: string[]) => any
 >obj : X
 >foo : (x: number, y: number, ...z: string[]) => any
+>...a : string
 >a : string[]
 
 xa[1].foo(1, 2, "abc");
@@ -101,6 +107,7 @@ xa[1].foo(1, 2, ...a);
 >xa[1] : X
 >xa : X[]
 >foo : (x: number, y: number, ...z: string[]) => any
+>...a : string
 >a : string[]
 
 xa[1].foo(1, 2, ...a, "abc");
@@ -109,6 +116,7 @@ xa[1].foo(1, 2, ...a, "abc");
 >xa[1] : X
 >xa : X[]
 >foo : (x: number, y: number, ...z: string[]) => any
+>...a : string
 >a : string[]
 
 (<Function>xa[1].foo)(...[1, 2, "abc"]);
@@ -120,6 +128,7 @@ xa[1].foo(1, 2, ...a, "abc");
 >xa[1] : X
 >xa : X[]
 >foo : (x: number, y: number, ...z: string[]) => any
+>...[1, 2, "abc"] : string | number
 >[1, 2, "abc"] : (string | number)[]
 
 class C {
@@ -145,6 +154,7 @@ class C {
 >foo : (x: number, y: number, ...z: string[]) => void
 >x : number
 >y : number
+>...z : string
 >z : string[]
     }
     foo(x: number, y: number, ...z: string[]) {
@@ -167,6 +177,7 @@ class D extends C {
         super(1, 2, ...a);
 >super(1, 2, ...a) : void
 >super : typeof C
+>...a : string
 >a : string[]
     }
     foo() {
@@ -183,6 +194,7 @@ class D extends C {
 >super.foo : (x: number, y: number, ...z: string[]) => void
 >super : C
 >foo : (x: number, y: number, ...z: string[]) => void
+>...a : string
 >a : string[]
     }
 }
@@ -192,5 +204,6 @@ var c = new C(1, 2, ...a);
 >c : C
 >new C(1, 2, ...a) : C
 >C : typeof C
+>...a : string
 >a : string[]
 

tests/baselines/reference/classDeclarationBlockScoping1.errors.txt

@@ -0,0 +1,13 @@
+tests/cases/compiler/classDeclarationBlockScoping1.ts(5,11): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+
+
+==== tests/cases/compiler/classDeclarationBlockScoping1.ts (1 errors) ====
+    class C {
+    }
+    
+    {
+        class C {
+              ~
+!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+        }
+    }

tests/baselines/reference/classDeclarationBlockScoping1.js

@@ -0,0 +1,22 @@
+//// [classDeclarationBlockScoping1.ts]
+class C {
+}
+
+{
+    class C {
+    }
+}
+
+//// [classDeclarationBlockScoping1.js]
+var C = (function () {
+    function C() {
+    }
+    return C;
+})();
+{
+    var C = (function () {
+        function C() {
+        }
+        return C;
+    })();
+}

tests/baselines/reference/classDeclarationBlockScoping2.errors.txt

@@ -0,0 +1,18 @@
+tests/cases/compiler/classDeclarationBlockScoping2.ts(2,11): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+tests/cases/compiler/classDeclarationBlockScoping2.ts(5,15): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+
+
+==== tests/cases/compiler/classDeclarationBlockScoping2.ts (2 errors) ====
+    function f() {
+        class C {}
+              ~
+!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+        var c1 = C;
+        {
+            class C {}
+                  ~
+!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
+            var c2 = C;
+        }
+        return C === c1;
+    }

tests/baselines/reference/classDeclarationBlockScoping2.js

@@ -0,0 +1,29 @@
+//// [classDeclarationBlockScoping2.ts]
+function f() {
+    class C {}
+    var c1 = C;
+    {
+        class C {}
+        var c2 = C;
+    }
+    return C === c1;
+}
+
+//// [classDeclarationBlockScoping2.js]
+function f() {
+    var C = (function () {
+        function C() {
+        }
+        return C;
+    })();
+    var c1 = C;
+    {
+        var C = (function () {
+            function C() {
+            }
+            return C;
+        })();
+        var c2 = C;
+    }
+    return C === c1;
+}

tests/baselines/reference/classExpressionWithDecorator1.errors.txt

@@ -0,0 +1,10 @@
+tests/cases/compiler/classExpressionWithDecorator1.ts(1,9): error TS1109: Expression expected.
+tests/cases/compiler/classExpressionWithDecorator1.ts(1,10): error TS2304: Cannot find name 'decorate'.
+
+
+==== tests/cases/compiler/classExpressionWithDecorator1.ts (2 errors) ====
+    var v = @decorate class C { static p = 1 };
+            ~
+!!! error TS1109: Expression expected.
+             ~~~~~~~~
+!!! error TS2304: Cannot find name 'decorate'.

tests/baselines/reference/classExpressionWithDecorator1.js

@@ -0,0 +1,22 @@
+//// [classExpressionWithDecorator1.ts]
+var v = @decorate class C { static p = 1 };
+
+//// [classExpressionWithDecorator1.js]
+var __decorate = this.__decorate || (typeof Reflect === "object" && Reflect.decorate) || function (decorators, target, key, desc) {
+    switch (arguments.length) {
+        case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
+        case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
+        case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
+    }
+};
+var v = ;
+var C = (function () {
+    function C() {
+    }
+    C.p = 1;
+    C = __decorate([
+        decorate
+    ], C);
+    return C;
+})();
+;

tests/baselines/reference/classExpressionWithStaticProperties1.errors.txt

@@ -0,0 +1,7 @@
+tests/cases/compiler/classExpressionWithStaticProperties1.ts(1,15): error TS9003: 'class' expressions are not currently supported.
+
+
+==== tests/cases/compiler/classExpressionWithStaticProperties1.ts (1 errors) ====
+    var v = class C { static a = 1; static b = 2 };
+                  ~
+!!! error TS9003: 'class' expressions are not currently supported.

tests/baselines/reference/classExpressionWithStaticProperties1.js

@@ -0,0 +1,11 @@
+//// [classExpressionWithStaticProperties1.ts]
+var v = class C { static a = 1; static b = 2 };
+
+//// [classExpressionWithStaticProperties1.js]
+var v = (function () {
+    function C() {
+    }
+    C.a = 1;
+    C.b = 2;
+    return C;
+})();

tests/baselines/reference/classExpressionWithStaticProperties2.errors.txt

@@ -0,0 +1,7 @@
+tests/cases/compiler/classExpressionWithStaticProperties2.ts(1,15): error TS9003: 'class' expressions are not currently supported.
+
+
+==== tests/cases/compiler/classExpressionWithStaticProperties2.ts (1 errors) ====
+    var v = class C { static a = 1; static b };
+                  ~
+!!! error TS9003: 'class' expressions are not currently supported.

tests/baselines/reference/classExpressionWithStaticProperties2.js

@@ -0,0 +1,10 @@
+//// [classExpressionWithStaticProperties2.ts]
+var v = class C { static a = 1; static b };
+
+//// [classExpressionWithStaticProperties2.js]
+var v = (function () {
+    function C() {
+    }
+    C.a = 1;
+    return C;
+})();

tests/baselines/reference/classExpressionWithStaticPropertiesES61.errors.txt

@@ -0,0 +1,7 @@
+tests/cases/compiler/classExpressionWithStaticPropertiesES61.ts(1,15): error TS9003: 'class' expressions are not currently supported.
+
+
+==== tests/cases/compiler/classExpressionWithStaticPropertiesES61.ts (1 errors) ====
+    var v = class C { static a = 1; static b = 2 };
+                  ~
+!!! error TS9003: 'class' expressions are not currently supported.

tests/baselines/reference/classExpressionWithStaticPropertiesES61.js

@@ -0,0 +1,10 @@
+//// [classExpressionWithStaticPropertiesES61.ts]
+var v = class C { static a = 1; static b = 2 };
+
+//// [classExpressionWithStaticPropertiesES61.js]
+var v = (_a = class C {
+    },
+    _a.a = 1,
+    _a.b = 2,
+    _a);
+var _a;

tests/baselines/reference/classExpressionWithStaticPropertiesES62.errors.txt

@@ -0,0 +1,7 @@
+tests/cases/compiler/classExpressionWithStaticPropertiesES62.ts(1,15): error TS9003: 'class' expressions are not currently supported.
+
+
+==== tests/cases/compiler/classExpressionWithStaticPropertiesES62.ts (1 errors) ====
+    var v = class C { static a = 1; static b };
+                  ~
+!!! error TS9003: 'class' expressions are not currently supported.

tests/baselines/reference/classExpressionWithStaticPropertiesES62.js

@@ -0,0 +1,9 @@
+//// [classExpressionWithStaticPropertiesES62.ts]
+var v = class C { static a = 1; static b };
+
+//// [classExpressionWithStaticPropertiesES62.js]
+var v = (_a = class C {
+    },
+    _a.a = 1,
+    _a);
+var _a;

tests/baselines/reference/classWithPredefinedTypesAsNames2.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/conformance/classes/classDeclarations/classWithPredefinedTypesAsNames2.ts(3,7): error TS1003: Identifier expected.
+tests/cases/conformance/classes/classDeclarations/classWithPredefinedTypesAsNames2.ts(3,7): error TS1005: '{' expected.
 
 
 ==== tests/cases/conformance/classes/classDeclarations/classWithPredefinedTypesAsNames2.ts (1 errors) ====
@@ -6,4 +6,4 @@ tests/cases/conformance/classes/classDeclarations/classWithPredefinedTypesAsName
     
     class void {}
           ~~~~
-!!! error TS1003: Identifier expected.
+!!! error TS1005: '{' expected.

tests/baselines/reference/classWithPredefinedTypesAsNames2.js

@@ -5,9 +5,9 @@ class void {}
 
 //// [classWithPredefinedTypesAsNames2.js]
 // classes cannot use predefined types as names
-var  = (function () {
-    function () {
+var default_1 = (function () {
+    function default_1() {
     }
-    return ;
+    return default_1;
 })();
 void {};

tests/baselines/reference/collisionArgumentsClassConstructor.errors.txt

@@ -1,40 +1,89 @@
 tests/cases/compiler/collisionArgumentsClassConstructor.ts(3,28): error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(3,31): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(4,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(8,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
 tests/cases/compiler/collisionArgumentsClassConstructor.ts(8,17): error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(9,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(13,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(14,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(20,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(25,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
 tests/cases/compiler/collisionArgumentsClassConstructor.ts(30,17): error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(30,24): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(31,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(35,24): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(36,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(41,31): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(44,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(47,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(51,31): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(52,31): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
 tests/cases/compiler/collisionArgumentsClassConstructor.ts(53,25): error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(53,28): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(54,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(59,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(60,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(61,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
 tests/cases/compiler/collisionArgumentsClassConstructor.ts(61,17): error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(62,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(67,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(68,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(69,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(70,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(75,31): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(76,31): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(79,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(80,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(84,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassConstructor.ts(85,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
 
 
-==== tests/cases/compiler/collisionArgumentsClassConstructor.ts (5 errors) ====
+==== tests/cases/compiler/collisionArgumentsClassConstructor.ts (38 errors) ====
     // Constructors
     class c1 {
         constructor(i: number, ...arguments) { // error
                                ~~~~~~~~~~~~
 !!! error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
+                                  ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
             var arguments: any[]; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
     }
     class c12 {
         constructor(arguments: number, ...rest) { // error
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
                     ~~~~~~~~~~~~~~~~~
 !!! error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
             var arguments = 10; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
     }
     class c1NoError {
         constructor(arguments: number) { // no error
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
             var arguments = 10; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
     }
     
     class c2 {
         constructor(...restParameters) {
             var arguments = 10; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
     }
     class c2NoError {
         constructor() {
             var arguments = 10; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
     }
     
@@ -42,63 +91,113 @@ tests/cases/compiler/collisionArgumentsClassConstructor.ts(61,17): error TS2396:
         constructor(public arguments: number, ...restParameters) { //arguments is error
                     ~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
+                           ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
             var arguments = 10; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
     }
     class c3NoError {
         constructor(public arguments: number) { // no error
+                           ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
             var arguments = 10; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
     }
     
     declare class c4 {
         constructor(i: number, ...arguments); // No error - no code gen
+                                  ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
     }
     declare class c42 {
         constructor(arguments: number, ...rest); // No error - no code gen
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
     }
     declare class c4NoError {
         constructor(arguments: number);  // no error
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
     }
     
     class c5 {
         constructor(i: number, ...arguments); // no codegen no error
+                                  ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         constructor(i: string, ...arguments); // no codegen no error
+                                  ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         constructor(i: any, ...arguments) { // error
                             ~~~~~~~~~~~~
 !!! error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
+                               ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
             var arguments: any[]; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
     }
     
     class c52 {
         constructor(arguments: number, ...rest); // no codegen no error
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         constructor(arguments: string, ...rest); // no codegen no error
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         constructor(arguments: any, ...rest) { // error
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
                     ~~~~~~~~~~~~~~
 !!! error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
             var arguments: any; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
     }
     
     class c5NoError {
         constructor(arguments: number); // no error
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         constructor(arguments: string); // no error
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         constructor(arguments: any) { // no error
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
             var arguments: any; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
     }
     
     declare class c6 {
         constructor(i: number, ...arguments); // no codegen no error
+                                  ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         constructor(i: string, ...arguments); // no codegen no error
+                                  ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
     }
     declare class c62 {
         constructor(arguments: number, ...rest); // no codegen no error
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         constructor(arguments: string, ...rest); // no codegen no error
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
     }
     
     declare class c6NoError {
         constructor(arguments: number); // no error
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         constructor(arguments: string); // no error
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
     }

tests/baselines/reference/collisionArgumentsClassMethod.errors.txt

@@ -1,63 +1,150 @@
 tests/cases/compiler/collisionArgumentsClassMethod.ts(2,27): error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(2,30): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(3,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(5,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
 tests/cases/compiler/collisionArgumentsClassMethod.ts(5,17): error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(6,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(8,23): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(9,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(11,29): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(12,29): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
 tests/cases/compiler/collisionArgumentsClassMethod.ts(13,23): error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(13,26): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(14,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(16,16): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(17,16): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(18,16): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
 tests/cases/compiler/collisionArgumentsClassMethod.ts(18,16): error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(19,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(21,22): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(22,22): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(23,22): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(24,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(29,30): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(30,17): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(31,23): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(33,29): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(34,29): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(35,16): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(36,16): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(37,22): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(38,22): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(43,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
+tests/cases/compiler/collisionArgumentsClassMethod.ts(46,13): error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
 
 
-==== tests/cases/compiler/collisionArgumentsClassMethod.ts (4 errors) ====
+==== tests/cases/compiler/collisionArgumentsClassMethod.ts (33 errors) ====
     class c1 {
         public foo(i: number, ...arguments) { //arguments is error
                               ~~~~~~~~~~~~
 !!! error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
+                                 ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
             var arguments: any[]; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
         public foo1(arguments: number, ...rest) { //arguments is error
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
                     ~~~~~~~~~~~~~~~~~
 !!! error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
             var arguments = 10; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
         public fooNoError(arguments: number) { // no error
+                          ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
             var arguments = 10; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
         public f4(i: number, ...arguments); // no codegen no error
+                                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         public f4(i: string, ...arguments); // no codegen no error
+                                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         public f4(i: any, ...arguments) { // error
                           ~~~~~~~~~~~~
 !!! error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
+                             ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
             var arguments: any[]; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
         public f41(arguments: number, ...rest); // no codegen no error
+                   ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         public f41(arguments: string, ...rest); // no codegen no error
+                   ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         public f41(arguments: any, ...rest) { // error
+                   ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
                    ~~~~~~~~~~~~~~
 !!! error TS2396: Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.
             var arguments: any; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
         public f4NoError(arguments: number); // no error
+                         ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         public f4NoError(arguments: string); // no error
+                         ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         public f4NoError(arguments: any) { // no error
+                         ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
             var arguments: any; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
     }
     
     declare class c2 {
         public foo(i: number, ...arguments); // No error - no code gen
+                                 ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         public foo1(arguments: number, ...rest); // No error - no code gen
+                    ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         public fooNoError(arguments: number); // No error - no code gen
+                          ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
     
         public f4(i: number, ...arguments); // no codegen no error
+                                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         public f4(i: string, ...arguments); // no codegen no error
+                                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         public f41(arguments: number, ...rest); // no codegen no error
+                   ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         public f41(arguments: string, ...rest); // no codegen no error
+                   ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         public f4NoError(arguments: number); // no error
+                         ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         public f4NoError(arguments: string); // no error
+                         ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
     }
     
     class c3 {
         public foo(...restParameters) {
             var arguments = 10; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
         public fooNoError() {
             var arguments = 10; // no error
+                ~~~~~~~~~
+!!! error TS1210: Invalid use of 'arguments'. Class definitions are automatically in strict mode.
         }
     }

tests/baselines/reference/computedPropertyNames10_ES5.js

@@ -32,5 +32,6 @@ var v = (_a = {},
     _a[true] = function () { },
     _a["hello bye"] = function () { },
     _a["hello " + a + " bye"] = function () { },
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNames11_ES5.js

@@ -21,16 +21,61 @@ var s;
 var n;
 var a;
 var v = (_a = {},
-    _a[s] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a[n] = Object.defineProperty({ set: function (v) { }, enumerable: true, configurable: true }),
-    _a[s + s] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a[s + n] = Object.defineProperty({ set: function (v) { }, enumerable: true, configurable: true }),
-    _a[+s] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a[""] = Object.defineProperty({ set: function (v) { }, enumerable: true, configurable: true }),
-    _a[0] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a[a] = Object.defineProperty({ set: function (v) { }, enumerable: true, configurable: true }),
-    _a[true] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a["hello bye"] = Object.defineProperty({ set: function (v) { }, enumerable: true, configurable: true }),
-    _a["hello " + a + " bye"] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a);
+    Object.defineProperty(_a, s, {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, n, {
+        set: function (v) { },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, s + s, {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, s + n, {
+        set: function (v) { },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, +s, {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, "", {
+        set: function (v) { },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, 0, {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, a, {
+        set: function (v) { },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, true, {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, "hello bye", {
+        set: function (v) { },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, "hello " + a + " bye", {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNames18_ES5.js

@@ -9,6 +9,7 @@ function foo() {
 function foo() {
     var obj = (_a = {},
         _a[this.bar] = 0,
-        _a);
+        _a
+    );
     var _a;
 }

tests/baselines/reference/computedPropertyNames19_ES5.js

@@ -10,6 +10,7 @@ var M;
 (function (M) {
     var obj = (_a = {},
         _a[this.bar] = 0,
-        _a);
+        _a
+    );
     var _a;
 })(M || (M = {}));

tests/baselines/reference/computedPropertyNames1_ES5.js

@@ -6,7 +6,17 @@ var v = {
 
 //// [computedPropertyNames1_ES5.js]
 var v = (_a = {},
-    _a[0 + 1] = Object.defineProperty({ get: function () { return 0; }, enumerable: true, configurable: true }),
-    _a[0 + 1] = Object.defineProperty({ set: function (v) { }, enumerable: true, configurable: true }),
-    _a);
+    Object.defineProperty(_a, 0 + 1, {
+        get: function () { return 0; },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, 0 + 1, {
+        set: function (v) { } //No error
+        ,
+        enumerable: true,
+        configurable: true
+    }),
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNames20_ES5.js

@@ -6,5 +6,6 @@ var obj = {
 //// [computedPropertyNames20_ES5.js]
 var obj = (_a = {},
     _a[this.bar] = 0,
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNames22_ES5.js

@@ -15,7 +15,8 @@ var C = (function () {
     C.prototype.bar = function () {
         var obj = (_a = {},
             _a[this.bar()] = function () { },
-            _a);
+            _a
+        );
         return 0;
         var _a;
     };

tests/baselines/reference/computedPropertyNames23_ES5.js

@@ -15,9 +15,7 @@ var C = (function () {
     C.prototype.bar = function () {
         return 0;
     };
-    C.prototype[(_a = {},
-        _a[this.bar()] = 1,
-        _a)[0]] = function () { };
+    C.prototype[(_a = {}, _a[this.bar()] = 1, _a)[0]] = function () { };
     return C;
     var _a;
 })();

tests/baselines/reference/computedPropertyNames25_ES5.js

@@ -36,7 +36,8 @@ var C = (function (_super) {
     C.prototype.foo = function () {
         var obj = (_a = {},
             _a[_super.prototype.bar.call(this)] = function () { },
-            _a);
+            _a
+        );
         return 0;
         var _a;
     };

tests/baselines/reference/computedPropertyNames26_ES5.js

@@ -30,9 +30,7 @@ var C = (function (_super) {
     function C() {
         _super.apply(this, arguments);
     }
-    C.prototype[(_a = {},
-        _a[_super.bar.call(this)] = 1,
-        _a)[0]] = function () { };
+    C.prototype[(_a = {}, _a[_super.bar.call(this)] = 1, _a)[0]] = function () { };
     return C;
     var _a;
 })(Base);

tests/baselines/reference/computedPropertyNames28_ES5.js

@@ -28,7 +28,8 @@ var C = (function (_super) {
         _super.call(this);
         var obj = (_a = {},
             _a[(_super.call(this), "prop")] = function () { },
-            _a);
+            _a
+        );
         var _a;
     }
     return C;

tests/baselines/reference/computedPropertyNames29_ES5.js

@@ -19,7 +19,8 @@ var C = (function () {
         (function () {
             var obj = (_a = {},
                 _a[_this.bar()] = function () { },
-                _a);
+                _a
+            );
             var _a;
         });
         return 0;

tests/baselines/reference/computedPropertyNames30_ES5.js

@@ -33,8 +33,12 @@ var C = (function (_super) {
         _super.call(this);
         (function () {
             var obj = (_a = {},
+                // Ideally, we would capture this. But the reference is
+                // illegal, and not capturing this is consistent with
+                //treatment of other similar violations.
                 _a[(_super.call(this), "prop")] = function () { },
-                _a);
+                _a
+            );
             var _a;
         });
     }

tests/baselines/reference/computedPropertyNames31_ES5.js

@@ -40,7 +40,8 @@ var C = (function (_super) {
         (function () {
             var obj = (_a = {},
                 _a[_super.prototype.bar.call(_this)] = function () { },
-                _a);
+                _a
+            );
             var _a;
         });
         return 0;

tests/baselines/reference/computedPropertyNames33_ES5.js

@@ -17,7 +17,8 @@ var C = (function () {
     C.prototype.bar = function () {
         var obj = (_a = {},
             _a[foo()] = function () { },
-            _a);
+            _a
+        );
         return 0;
         var _a;
     };

tests/baselines/reference/computedPropertyNames34_ES5.js

@@ -17,7 +17,8 @@ var C = (function () {
     C.bar = function () {
         var obj = (_a = {},
             _a[foo()] = function () { },
-            _a);
+            _a
+        );
         return 0;
         var _a;
     };

tests/baselines/reference/computedPropertyNames3_ES5.errors.txt

@@ -1,12 +1,13 @@
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(4,12): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(5,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(5,9): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
+tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(5,17): error TS1102: 'delete' cannot be called on an identifier in strict mode.
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(6,9): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(7,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(7,16): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
 
 
-==== tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts (6 errors) ====
+==== tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts (7 errors) ====
     var id;
     class C {
         [0 + 1]() { }
@@ -18,6 +19,8 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(7,1
 !!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
             ~~~~~~~~~~~
 !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
+                    ~~
+!!! error TS1102: 'delete' cannot be called on an identifier in strict mode.
         set [[0, 1]](v) { }
             ~~~~~~~~
 !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.

tests/baselines/reference/computedPropertyNames46_ES5.js

@@ -6,5 +6,6 @@ var o = {
 //// [computedPropertyNames46_ES5.js]
 var o = (_a = {},
     _a["" || 0] = 0,
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNames47_ES5.js

@@ -16,5 +16,6 @@ var E2;
 })(E2 || (E2 = {}));
 var o = (_a = {},
     _a[E1.x || E2.x] = 0,
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNames48_ES5.js

@@ -25,11 +25,14 @@ var E;
 var a;
 extractIndexer((_a = {},
     _a[a] = "",
-    _a)); // Should return string
+    _a
+)); // Should return string
 extractIndexer((_b = {},
     _b[E.x] = "",
-    _b)); // Should return string
+    _b
+)); // Should return string
 extractIndexer((_c = {},
     _c["" || 0] = "",
-    _c)); // Should return any (widened form of undefined)
+    _c
+)); // Should return any (widened form of undefined)
 var _a, _b, _c;

tests/baselines/reference/computedPropertyNames49_ES5.js

@@ -27,24 +27,41 @@ var x = {
 
 //// [computedPropertyNames49_ES5.js]
 var x = (_a = {
-    p1: 10
-},
-    _a.p1 = 10,
-    _a[1 + 1] = Object.defineProperty({ get: function () {
+        p1: 10
+    },
+    Object.defineProperty(_a, 1 + 1, {
+        get: function () {
             throw 10;
-        }, enumerable: true, configurable: true }),
-    _a[1 + 1] = Object.defineProperty({ get: function () {
+        },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, 1 + 1, {
+        get: function () {
             return 10;
-        }, enumerable: true, configurable: true }),
-    _a[1 + 1] = Object.defineProperty({ set: function () {
+        },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, 1 + 1, {
+        set: function () {
             // just throw
             throw 10;
-        }, enumerable: true, configurable: true }),
-    _a.foo = Object.defineProperty({ get: function () {
+        },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, "foo", {
+        get: function () {
             if (1 == 1) {
                 return 10;
             }
-        }, enumerable: true, configurable: true }),
+        },
+        enumerable: true,
+        configurable: true
+    }),
+    ,
     _a.p2 = 20,
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNames4_ES5.js

@@ -32,5 +32,6 @@ var v = (_a = {},
     _a[true] = 0,
     _a["hello bye"] = 0,
     _a["hello " + a + " bye"] = 0,
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNames50_ES5.js

@@ -27,29 +27,37 @@ var x = {
 
 //// [computedPropertyNames50_ES5.js]
 var x = (_a = {
-    p1: 10,
-    get foo() {
-        if (1 == 1) {
-            return 10;
-        }
-    }
-},
-    _a.p1 = 10,
-    _a.foo = Object.defineProperty({ get: function () {
+        p1: 10,
+        get foo() {
             if (1 == 1) {
                 return 10;
             }
-        }, enumerable: true, configurable: true }),
-    _a[1 + 1] = Object.defineProperty({ get: function () {
+        }
+    },
+    Object.defineProperty(_a, 1 + 1, {
+        get: function () {
             throw 10;
-        }, enumerable: true, configurable: true }),
-    _a[1 + 1] = Object.defineProperty({ set: function () {
+        },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, 1 + 1, {
+        set: function () {
             // just throw
             throw 10;
-        }, enumerable: true, configurable: true }),
-    _a[1 + 1] = Object.defineProperty({ get: function () {
+        },
+        enumerable: true,
+        configurable: true
+    }),
+    Object.defineProperty(_a, 1 + 1, {
+        get: function () {
             return 10;
-        }, enumerable: true, configurable: true }),
+        },
+        enumerable: true,
+        configurable: true
+    }),
+    ,
     _a.p2 = 20,
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNames5_ES5.js

@@ -18,5 +18,6 @@ var v = (_a = {},
     _a[{}] = 0,
     _a[undefined] = undefined,
     _a[null] = null,
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNames6_ES5.js

@@ -16,5 +16,6 @@ var v = (_a = {},
     _a[p1] = 0,
     _a[p2] = 1,
     _a[p3] = 2,
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNames7_ES5.js

@@ -13,5 +13,6 @@ var E;
 })(E || (E = {}));
 var v = (_a = {},
     _a[E.member] = 0,
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNames8_ES5.js

@@ -15,6 +15,7 @@ function f() {
     var v = (_a = {},
         _a[t] = 0,
         _a[u] = 1,
-        _a);
+        _a
+    );
     var _a;
 }

tests/baselines/reference/computedPropertyNames9_ES5.js

@@ -16,5 +16,6 @@ var v = (_a = {},
     _a[f("")] = 0,
     _a[f(0)] = 0,
     _a[f(true)] = 0,
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNamesContextualType10_ES5.js

@@ -12,5 +12,6 @@ var o: I = {
 var o = (_a = {},
     _a[+"foo"] = "",
     _a[+"bar"] = 0,
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNamesContextualType1_ES5.js

@@ -13,5 +13,6 @@ var o: I = {
 var o = (_a = {},
     _a["" + 0] = function (y) { return y.length; },
     _a["" + 1] = function (y) { return y.length; },
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNamesContextualType2_ES5.js

@@ -13,5 +13,6 @@ var o: I = {
 var o = (_a = {},
     _a[+"foo"] = function (y) { return y.length; },
     _a[+"bar"] = function (y) { return y.length; },
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNamesContextualType3_ES5.js

@@ -12,5 +12,6 @@ var o: I = {
 var o = (_a = {},
     _a[+"foo"] = function (y) { return y.length; },
     _a[+"bar"] = function (y) { return y.length; },
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNamesContextualType4_ES5.js

@@ -13,5 +13,6 @@ var o: I = {
 var o = (_a = {},
     _a["" + "foo"] = "",
     _a["" + "bar"] = 0,
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNamesContextualType5_ES5.js

@@ -13,5 +13,6 @@ var o: I = {
 var o = (_a = {},
     _a[+"foo"] = "",
     _a[+"bar"] = 0,
-    _a);
+    _a
+);
 var _a;

tests/baselines/reference/computedPropertyNamesContextualType6_ES5.js

@@ -15,13 +15,12 @@ foo({
 
 //// [computedPropertyNamesContextualType6_ES5.js]
 foo((_a = {
-    p: "",
-    0: function () { }
-},
-    _a.p = "",
-    _a[0] = function () { },
+        p: "",
+        0: function () { }
+    },
     _a["hi" + "bye"] = true,
     _a[0 + 1] = 0,
     _a[+"hi"] = [0],
-    _a));
+    _a
+));
 var _a;

tests/baselines/reference/computedPropertyNamesContextualType7_ES5.js

@@ -15,13 +15,12 @@ foo({
 
 //// [computedPropertyNamesContextualType7_ES5.js]
 foo((_a = {
-    p: "",
-    0: function () { }
-},
-    _a.p = "",
-    _a[0] = function () { },
+        p: "",
+        0: function () { }
+    },
     _a["hi" + "bye"] = true,
     _a[0 + 1] = 0,
     _a[+"hi"] = [0],
-    _a));
+    _a
+));
 var _a;