Merge branch 'master' into conformanceTypeGuard

src/compiler/checker.ts

@@ -2197,25 +2197,7 @@ module ts {
             }
             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);
+                return languageVersion >= ScriptTarget.ES6 ? createIterableType(unionOfElements) : createArrayType(unionOfElements);
             }
 
             // If the pattern has at least one element, and no rest element, then it should imply a tuple type.
@@ -5422,8 +5404,8 @@ module ts {
             // will be bound to non-arrow function that contain this arrow function. This results in inconsistent behavior.
             // To avoid that we will give an error to users if they use arguments objects in arrow function so that they
             // can explicitly bound arguments objects
-            if (symbol === argumentsSymbol && getContainingFunction(node).kind === SyntaxKind.ArrowFunction) {
-                error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_Consider_using_a_standard_function_expression);
+            if (symbol === argumentsSymbol && getContainingFunction(node).kind === SyntaxKind.ArrowFunction && languageVersion < ScriptTarget.ES6) {
+                error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression);
             }
 
             if (symbol.flags & SymbolFlags.Alias && !isInTypeQuery(node) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) {
@@ -6035,14 +6017,38 @@ module ts {
             }
             let hasSpreadElement = false;
             let elementTypes: Type[] = [];
+            let inDestructuringPattern = isAssignmentTarget(node);
             for (let e of elements) {
-                let type = checkExpression(e, contextualMapper);
-                elementTypes.push(type);
+                if (inDestructuringPattern && e.kind === SyntaxKind.SpreadElementExpression) {
+                    // Given the following situation:
+                    //    var c: {};
+                    //    [...c] = ["", 0];
+                    //
+                    // c is represented in the tree as a spread element in an array literal.
+                    // But c really functions as a rest element, and its purpose is to provide
+                    // a contextual type for the right hand side of the assignment. Therefore,
+                    // instead of calling checkExpression on "...c", which will give an error 
+                    // if c is not iterable/array-like, we need to act as if we are trying to
+                    // get the contextual element type from it. So we do something similar to
+                    // getContextualTypeForElementExpression, which will crucially not error
+                    // if there is no index type / iterated type.
+                    let restArrayType = checkExpression((<SpreadElementExpression>e).expression, contextualMapper);
+                    let restElementType = getIndexTypeOfType(restArrayType, IndexKind.Number) ||
+                        (languageVersion >= ScriptTarget.ES6 ? checkIteratedType(restArrayType, /*expressionForError*/ undefined) : undefined);
+                    
+                    if (restElementType) {
+                        elementTypes.push(restElementType);
+                    }
+                }
+                else {
+                    let type = checkExpression(e, contextualMapper);
+                    elementTypes.push(type);
+                }
                 hasSpreadElement = hasSpreadElement || e.kind === SyntaxKind.SpreadElementExpression;
             }
             if (!hasSpreadElement) {
                 let contextualType = getContextualType(node);
-                if (contextualType && contextualTypeIsTupleLikeType(contextualType) || isAssignmentTarget(node)) {
+                if (contextualType && contextualTypeIsTupleLikeType(contextualType) || inDestructuringPattern) {
                     return createTupleType(elementTypes);
                 }
             }
@@ -7633,7 +7639,7 @@ module ts {
             // 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 elementType = checkIteratedTypeOrElementType(sourceType, node, /*allowStringInput*/ false) || unknownType;
             let elements = node.elements;
             for (let i = 0; i < elements.length; i++) {
                 let e = elements[i];
@@ -7657,11 +7663,17 @@ module ts {
                         }
                     }
                     else {
-                        if (i === elements.length - 1) {
-                            checkReferenceAssignment((<SpreadElementExpression>e).expression, createArrayType(elementType), contextualMapper);
+                        if (i < elements.length - 1) {
+                            error(e, Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern);
                         }
                         else {
-                            error(e, Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern);
+                            let restExpression = (<SpreadElementExpression>e).expression;
+                            if (restExpression.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>restExpression).operatorToken.kind === SyntaxKind.EqualsToken) {
+                                error((<BinaryExpression>restExpression).operatorToken, Diagnostics.A_rest_element_cannot_have_an_initializer);
+                            }
+                            else {
+                                checkDestructuringAssignment(restExpression, createArrayType(elementType), contextualMapper);
+                            }
                         }
                     }
                 }
@@ -8121,10 +8133,11 @@ module ts {
             if (node.questionToken && isBindingPattern(node.name) && func.body) {
                 error(node, Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature);
             }
-            if (node.dotDotDotToken) {
-                if (!isArrayType(getTypeOfSymbol(node.symbol))) {
-                    error(node, Diagnostics.A_rest_parameter_must_be_of_an_array_type);
-                }
+            
+            // Only check rest parameter type if it's not a binding pattern. Since binding patterns are
+            // not allowed in a rest parameter, we already have an error from checkGrammarParameterList.
+            if (node.dotDotDotToken && !isBindingPattern(node.name) && !isArrayType(getTypeOfSymbol(node.symbol))) {
+                error(node, Diagnostics.A_rest_parameter_must_be_of_an_array_type);
             }
         }
 
@@ -9427,6 +9440,10 @@ module ts {
         }
 
         function checkIteratedTypeOrElementType(inputType: Type, errorNode: Node, allowStringInput: boolean): Type {
+            if (inputType.flags & TypeFlags.Any) {
+                return inputType;
+            }
+
             if (languageVersion >= ScriptTarget.ES6) {
                 return checkIteratedType(inputType, errorNode) || anyType;
             }
@@ -10417,13 +10434,29 @@ module ts {
         function getFirstNonAmbientClassOrFunctionDeclaration(symbol: Symbol): Declaration {
             let declarations = symbol.declarations;
             for (let declaration of declarations) {
-                if ((declaration.kind === SyntaxKind.ClassDeclaration || (declaration.kind === SyntaxKind.FunctionDeclaration && nodeIsPresent((<FunctionLikeDeclaration>declaration).body))) && !isInAmbientContext(declaration)) {
+                if ((declaration.kind === SyntaxKind.ClassDeclaration ||
+                    (declaration.kind === SyntaxKind.FunctionDeclaration && nodeIsPresent((<FunctionLikeDeclaration>declaration).body))) &&
+                    !isInAmbientContext(declaration)) {
                     return declaration;
                 }
             }
             return undefined;
         }
 
+        function inSameLexicalScope(node1: Node, node2: Node) {
+            let container1 = getEnclosingBlockScopeContainer(node1);
+            let container2 = getEnclosingBlockScopeContainer(node2);
+            if (isGlobalSourceFile(container1)) {
+                return isGlobalSourceFile(container2);
+            }
+            else if (isGlobalSourceFile(container2)) {
+                return false;
+            }
+            else {
+                return container1 === container2;
+            }
+        }
+
         function checkModuleDeclaration(node: ModuleDeclaration) {
             if (produceDiagnostics) {
                 // Grammar checking
@@ -10443,15 +10476,23 @@ module ts {
                     && symbol.declarations.length > 1
                     && !isInAmbientContext(node)
                     && isInstantiatedModule(node, compilerOptions.preserveConstEnums || compilerOptions.separateCompilation)) {
-                    let classOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol);
-                    if (classOrFunc) {
-                        if (getSourceFileOfNode(node) !== getSourceFileOfNode(classOrFunc)) {
+                    let firstNonAmbientClassOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol);
+                    if (firstNonAmbientClassOrFunc) {
+                        if (getSourceFileOfNode(node) !== getSourceFileOfNode(firstNonAmbientClassOrFunc)) {
                             error(node.name, Diagnostics.A_module_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged);
                         }
-                        else if (node.pos < classOrFunc.pos) {
+                        else if (node.pos < firstNonAmbientClassOrFunc.pos) {
                             error(node.name, Diagnostics.A_module_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged);
                         }
                     }
+
+                    // if the module merges with a class declaration in the same lexical scope, 
+                    // we need to track this to ensure the correct emit.
+                    let mergedClass = getDeclarationOfKind(symbol, SyntaxKind.ClassDeclaration);                    
+                    if (mergedClass &&
+                        inSameLexicalScope(node, mergedClass)) {
+                        getNodeLinks(node).flags |= NodeCheckFlags.LexicalModuleMergesWithClass;
+                    }
                 }
 
                 // Checks for ambient external modules.
@@ -12270,6 +12311,10 @@ module ts {
                         return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
                     }
 
+                    if (isBindingPattern(parameter.name)) {
+                        return grammarErrorOnNode(parameter.name, Diagnostics.A_rest_element_cannot_contain_a_binding_pattern);
+                    }
+
                     if (parameter.questionToken) {
                         return grammarErrorOnNode(parameter.questionToken, Diagnostics.A_rest_parameter_cannot_be_optional);
                     }
@@ -12756,6 +12801,11 @@ module ts {
                 if (node !== elements[elements.length - 1]) {
                     return grammarErrorOnNode(node, Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern);
                 }
+
+                if (node.name.kind === SyntaxKind.ArrayBindingPattern || node.name.kind === SyntaxKind.ObjectBindingPattern) {
+                    return grammarErrorOnNode(node.name, Diagnostics.A_rest_element_cannot_contain_a_binding_pattern);
+                }
+
                 if (node.initializer) {
                     // Error on equals token which immediate precedes the initializer
                     return grammarErrorAtPos(getSourceFileOfNode(node), node.initializer.pos - 1, 1, Diagnostics.A_rest_element_cannot_have_an_initializer);
@@ -12953,6 +13003,11 @@ module ts {
             }
         }
 
+        function isEvalOrArgumentsIdentifier(node: Node): boolean {
+            return node.kind === SyntaxKind.Identifier &&
+                ((<Identifier>node).text === "eval" || (<Identifier>node).text === "arguments");
+        }
+
         function checkGrammarConstructorTypeParameters(node: ConstructorDeclaration) {
             if (node.typeParameters) {
                 return grammarErrorAtPos(getSourceFileOfNode(node), node.typeParameters.pos, node.typeParameters.end - node.typeParameters.pos, Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration);

src/compiler/diagnosticInformationMap.generated.ts

@@ -358,11 +358,12 @@ module ts {
         Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2: { code: 2493, category: DiagnosticCategory.Error, key: "Tuple type '{0}' with length '{1}' cannot be assigned to tuple with length '{2}'." },
         Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher: { code: 2494, category: DiagnosticCategory.Error, key: "Using a string in a 'for...of' statement is only supported in ECMAScript 5 and higher." },
         Type_0_is_not_an_array_type_or_a_string_type: { code: 2495, category: DiagnosticCategory.Error, key: "Type '{0}' is not an array type or a string type." },
-        The_arguments_object_cannot_be_referenced_in_an_arrow_function_Consider_using_a_standard_function_expression: { code: 2496, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression." },
+        The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression: { code: 2496, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression." },
         External_module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct: { code: 2497, category: DiagnosticCategory.Error, key: "External module '{0}' resolves to a non-module entity and cannot be imported using this construct." },
         External_module_0_uses_export_and_cannot_be_used_with_export_Asterisk: { code: 2498, category: DiagnosticCategory.Error, key: "External module '{0}' uses 'export =' and cannot be used with 'export *'." },
         An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2499, category: DiagnosticCategory.Error, key: "An interface can only extend an identifier/qualified-name with optional type arguments." },
         A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2500, category: DiagnosticCategory.Error, key: "A class can only implement an identifier/qualified-name with optional type arguments." },
+        A_rest_element_cannot_contain_a_binding_pattern: { code: 2501, category: DiagnosticCategory.Error, key: "A rest element cannot contain a binding pattern." },
         Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." },
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." },
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." },

src/compiler/diagnosticMessages.json

@@ -1419,7 +1419,7 @@
         "category": "Error",
         "code": 2495
     },
-    "The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression.": {
+    "The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression.": {
         "category": "Error",
         "code": 2496
     },
@@ -1439,6 +1439,10 @@
         "category": "Error",
         "code": 2500
     },
+    "A rest element cannot contain a binding pattern.": {
+        "category": "Error",
+        "code": 2501
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

src/compiler/emitter.ts

@@ -1589,23 +1589,40 @@ var __param = this.__param || function(index, decorator) { return function (targ
                 return result;
             }
 
-            function createPropertyAccessExpression(expression: LeftHandSideExpression, name: Identifier): PropertyAccessExpression {
+            function createPropertyAccessExpression(expression: Expression, name: Identifier): PropertyAccessExpression {
                 let result = <PropertyAccessExpression>createSynthesizedNode(SyntaxKind.PropertyAccessExpression);
-                result.expression = expression;
+                result.expression = parenthesizeForAccess(expression);
                 result.dotToken = createSynthesizedNode(SyntaxKind.DotToken);
                 result.name = name;
 
                 return result;
-             }
+            }
 
-            function createElementAccessExpression(expression: LeftHandSideExpression, argumentExpression: Expression): ElementAccessExpression {
+            function createElementAccessExpression(expression: Expression, argumentExpression: Expression): ElementAccessExpression {
                 let result = <ElementAccessExpression>createSynthesizedNode(SyntaxKind.ElementAccessExpression);
-                result.expression = expression;
+                result.expression = parenthesizeForAccess(expression);
                 result.argumentExpression = argumentExpression;
 
                 return result;
             }
 
+            function parenthesizeForAccess(expr: Expression): LeftHandSideExpression {
+                // isLeftHandSideExpression is almost the correct criterion for when it is not necessary
+                // to parenthesize the expression before a dot. The known exceptions are:
+                //
+                //    NewExpression:
+                //       new C.x        -> not the same as (new C).x
+                //    NumberLiteral
+                //       1.x            -> not the same as (1).x
+                //
+                if (isLeftHandSideExpression(expr) && expr.kind !== SyntaxKind.NewExpression && expr.kind !== SyntaxKind.NumericLiteral) {
+                    return <LeftHandSideExpression>expr;
+                }
+                let node = <ParenthesizedExpression>createSynthesizedNode(SyntaxKind.ParenthesizedExpression);
+                node.expression = expr;
+                return node;
+            }
+
             function emitComputedPropertyName(node: ComputedPropertyName) {
                 write("[");
                 emitExpressionForPropertyName(node);
@@ -2276,7 +2293,7 @@ var __param = this.__param || function(index, decorator) { return function (targ
                     if (node.initializer.kind === SyntaxKind.ArrayLiteralExpression || node.initializer.kind === SyntaxKind.ObjectLiteralExpression) {
                         // This is a destructuring pattern, so call emitDestructuring instead of emit. Calling emit will not work, because it will cause
                         // the BinaryExpression to be passed in instead of the expression statement, which will cause emitDestructuring to crash.
-                        emitDestructuring(assignmentExpression, /*isAssignmentExpressionStatement*/ true, /*value*/ undefined, /*locationForCheckingExistingName*/ node);
+                        emitDestructuring(assignmentExpression, /*isAssignmentExpressionStatement*/ true, /*value*/ undefined);
                     }
                     else {
                         emitNodeWithoutSourceMap(assignmentExpression);
@@ -2480,16 +2497,7 @@ var __param = this.__param || function(index, decorator) { return function (targ
                 }
             }
 
-            /**
-             * If the root has a chance of being a synthesized node, callers should also pass a value for
-             * lowestNonSynthesizedAncestor. This should be an ancestor of root, it should not be synthesized,
-             * and there should not be a lower ancestor that introduces a scope. This node will be used as the
-             * location for ensuring that temporary names are unique.
-             */
-            function emitDestructuring(root: BinaryExpression | VariableDeclaration | ParameterDeclaration,
-                isAssignmentExpressionStatement: boolean,
-                value?: Expression,
-                lowestNonSynthesizedAncestor?: Node) {
+            function emitDestructuring(root: BinaryExpression | VariableDeclaration | ParameterDeclaration, isAssignmentExpressionStatement: boolean, value?: Expression) {
                 let emitCount = 0;
                 // An exported declaration is actually emitted as an assignment (to a property on the module object), so
                 // temporary variables in an exported declaration need to have real declarations elsewhere
@@ -2520,9 +2528,6 @@ var __param = this.__param || function(index, decorator) { return function (targ
 
                 function ensureIdentifier(expr: Expression): Expression {
                     if (expr.kind !== SyntaxKind.Identifier) {
-                        // In case the root is a synthesized node, we need to pass lowestNonSynthesizedAncestor
-                        // as the location for determining uniqueness of the variable we are about to
-                        // generate.
                         let identifier = createTempVariable(TempFlags.Auto);
                         if (!isDeclaration) {
                             recordTempDeclaration(identifier);
@@ -2561,27 +2566,22 @@ var __param = this.__param || function(index, decorator) { return function (targ
                     return node;
                 }
 
-                function parenthesizeForAccess(expr: Expression): LeftHandSideExpression {
-                    if (expr.kind === SyntaxKind.Identifier || expr.kind === SyntaxKind.PropertyAccessExpression || expr.kind === SyntaxKind.ElementAccessExpression) {
-                        return <LeftHandSideExpression>expr;
-                    }
-                    let node = <ParenthesizedExpression>createSynthesizedNode(SyntaxKind.ParenthesizedExpression);
-                    node.expression = expr;
-                    return node;
-                }
-
-                function createPropertyAccess(object: Expression, propName: Identifier): Expression {
+                function createPropertyAccessForDestructuringProperty(object: Expression, propName: Identifier | LiteralExpression): Expression {
                     if (propName.kind !== SyntaxKind.Identifier) {
-                        return createElementAccess(object, propName);
+                        return createElementAccessExpression(object, propName);
                     }
-                    return createPropertyAccessExpression(parenthesizeForAccess(object), propName);
+
+                    return createPropertyAccessExpression(object, propName);
                 }
 
-                function createElementAccess(object: Expression, index: Expression): Expression {
-                    let node = <ElementAccessExpression>createSynthesizedNode(SyntaxKind.ElementAccessExpression);
-                    node.expression = parenthesizeForAccess(object);
-                    node.argumentExpression = index;
-                    return node;
+                function createSliceCall(value: Expression, sliceIndex: number): CallExpression {
+                    let call = <CallExpression>createSynthesizedNode(SyntaxKind.CallExpression);
+                    let sliceIdentifier = <Identifier>createSynthesizedNode(SyntaxKind.Identifier);
+                    sliceIdentifier.text = "slice";
+                    call.expression = createPropertyAccessExpression(value, sliceIdentifier);
+                    call.arguments = <NodeArray<LiteralExpression>>createSynthesizedNodeArray();
+                    call.arguments[0] = createNumericLiteral(sliceIndex);
+                    return call;
                 }
 
                 function emitObjectLiteralAssignment(target: ObjectLiteralExpression, value: Expression) {
@@ -2594,8 +2594,8 @@ var __param = this.__param || function(index, decorator) { return function (targ
                     for (let p of properties) {
                         if (p.kind === SyntaxKind.PropertyAssignment || p.kind === SyntaxKind.ShorthandPropertyAssignment) {
                             // TODO(andersh): Computed property support
-                            let propName = <Identifier>((<PropertyAssignment>p).name);
-                            emitDestructuringAssignment((<PropertyAssignment>p).initializer || propName, createPropertyAccess(value, propName));
+                            let propName = <Identifier | LiteralExpression>((<PropertyAssignment>p).name);
+                            emitDestructuringAssignment((<PropertyAssignment>p).initializer || propName, createPropertyAccessForDestructuringProperty(value, propName));
                         }
                     }
                 }
@@ -2611,14 +2611,10 @@ var __param = this.__param || function(index, decorator) { return function (targ
                         let e = elements[i];
                         if (e.kind !== SyntaxKind.OmittedExpression) {
                             if (e.kind !== SyntaxKind.SpreadElementExpression) {
-                                emitDestructuringAssignment(e, createElementAccess(value, createNumericLiteral(i)));
+                                emitDestructuringAssignment(e, createElementAccessExpression(value, createNumericLiteral(i)));
                             }
-                            else {
-                                if (i === elements.length - 1) {
-                                    value = ensureIdentifier(value);
-                                    emitAssignment(<Identifier>(<SpreadElementExpression>e).expression, value);
-                                    write(".slice(" + i + ")");
-                                }
+                            else if (i === elements.length - 1) {
+                                emitDestructuringAssignment((<SpreadElementExpression>e).expression, createSliceCall(value, i));
                             }
                         }
                     }
@@ -2682,19 +2678,15 @@ var __param = this.__param || function(index, decorator) { return function (targ
                             if (pattern.kind === SyntaxKind.ObjectBindingPattern) {
                                 // Rewrite element to a declaration with an initializer that fetches property
                                 let propName = element.propertyName || <Identifier>element.name;
-                                emitBindingElement(element, createPropertyAccess(value, propName));
+                                emitBindingElement(element, createPropertyAccessForDestructuringProperty(value, propName));
                             }
                             else if (element.kind !== SyntaxKind.OmittedExpression) {
                                 if (!element.dotDotDotToken) {
                                     // Rewrite element to a declaration that accesses array element at index i
-                                    emitBindingElement(element, createElementAccess(value, createNumericLiteral(i)));
+                                    emitBindingElement(element, createElementAccessExpression(value, createNumericLiteral(i)));
                                 }
-                                else {
-                                    if (i === elements.length - 1) {
-                                        value = ensureIdentifier(value);
-                                        emitAssignment(<Identifier>element.name, value);
-                                        write(".slice(" + i + ")");
-                                    }
+                                else if (i === elements.length - 1) {
+                                    emitBindingElement(element, createSliceCall(value, i));
                                 }
                             }
                         }
@@ -2862,6 +2854,12 @@ var __param = this.__param || function(index, decorator) { return function (targ
                 if (languageVersion < ScriptTarget.ES6) {
                     let tempIndex = 0;
                     forEach(node.parameters, p => {
+                        // A rest parameter cannot have a binding pattern or an initializer,
+                        // so let's just ignore it.
+                        if (p.dotDotDotToken) {
+                            return;
+                        }
+
                         if (isBindingPattern(p.name)) {
                             writeLine();
                             write("var ");
@@ -2892,6 +2890,12 @@ var __param = this.__param || function(index, decorator) { return function (targ
                 if (languageVersion < ScriptTarget.ES6 && hasRestParameters(node)) {
                     let restIndex = node.parameters.length - 1;
                     let restParam = node.parameters[restIndex];
+
+                    // A rest parameter cannot have a binding pattern, so let's just ignore it if it does.
+                    if (isBindingPattern(restParam.name)) {
+                        return;
+                    }
+
                     let tempName = createTempVariable(TempFlags._i).text;
                     writeLine();
                     emitLeadingComments(restParam);
@@ -4207,6 +4211,10 @@ var __param = this.__param || function(index, decorator) { return function (targ
                 return isInstantiatedModule(node, compilerOptions.preserveConstEnums || compilerOptions.separateCompilation);
             }
 
+            function isModuleMergedWithES6Class(node: ModuleDeclaration) {
+                return languageVersion === ScriptTarget.ES6 && !!(resolver.getNodeCheckFlags(node) & NodeCheckFlags.LexicalModuleMergesWithClass);
+            }
+
             function emitModuleDeclaration(node: ModuleDeclaration) {
                 // Emit only if this module is non-ambient.
                 let shouldEmit = shouldEmitModuleDeclaration(node);
@@ -4215,15 +4223,19 @@ var __param = this.__param || function(index, decorator) { return function (targ
                     return emitOnlyPinnedOrTripleSlashComments(node);
                 }
 
-                emitStart(node);
-                if (isES6ExportedDeclaration(node)) {
-                    write("export ");
+                if (!isModuleMergedWithES6Class(node)) {
+                    emitStart(node);
+                    if (isES6ExportedDeclaration(node)) {
+                        write("export ");
+                    }
+
+                    write("var ");
+                    emit(node.name);
+                    write(";");
+                    emitEnd(node);
+                    writeLine();
                 }
-                write("var ");
-                emit(node.name);
-                write(";");
-                emitEnd(node);
-                writeLine();
+
                 emitStart(node);
                 write("(function (");
                 emitStart(node.name);

src/compiler/program.ts

@@ -54,6 +54,7 @@ module ts {
                 }
                 text = "";
             }
+
             return text !== undefined ? createSourceFile(fileName, text, languageVersion, setParentNodes) : undefined;
         }
 

src/compiler/scanner.ts

@@ -25,6 +25,8 @@ module ts {
         reScanTemplateToken(): SyntaxKind;
         scan(): SyntaxKind;
         setText(text: string): void;
+        setOnError(onError: ErrorCallback): void;
+        setScriptTarget(scriptTarget: ScriptTarget): void;
         setTextPos(textPos: number): void;
         // Invokes the provided callback then unconditionally restores the scanner to the state it 
         // was in immediately prior to invoking the callback.  The result of invoking the callback
@@ -599,6 +601,7 @@ module ts {
     export function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback): Scanner {
         let pos: number;       // Current position (end position of text of current token)
         let len: number;       // Length of text
+
         let startPos: number;  // Start position of whitespace before current token
         let tokenPos: number;  // Start position of text of current token
         let token: SyntaxKind;
@@ -607,6 +610,32 @@ module ts {
         let hasExtendedUnicodeEscape: boolean;
         let tokenIsUnterminated: boolean;
 
+        setText(text);
+
+        return {
+            getStartPos: () => startPos,
+            getTextPos: () => pos,
+            getToken: () => token,
+            getTokenPos: () => tokenPos,
+            getTokenText: () => text.substring(tokenPos, pos),
+            getTokenValue: () => tokenValue,
+            hasExtendedUnicodeEscape: () => hasExtendedUnicodeEscape,
+            hasPrecedingLineBreak: () => precedingLineBreak,
+            isIdentifier: () => token === SyntaxKind.Identifier || token > SyntaxKind.LastReservedWord,
+            isReservedWord: () => token >= SyntaxKind.FirstReservedWord && token <= SyntaxKind.LastReservedWord,
+            isUnterminated: () => tokenIsUnterminated,
+            reScanGreaterToken,
+            reScanSlashToken,
+            reScanTemplateToken,
+            scan,
+            setText,
+            setScriptTarget,
+            setOnError,
+            setTextPos,
+            tryScan,
+            lookAhead,
+        };
+
         function error(message: DiagnosticMessage, length?: number): void {
             if (onError) {
                 onError(message, length || 0);
@@ -1450,37 +1479,24 @@ module ts {
             setTextPos(0);
         }
 
+        function setOnError(errorCallback: ErrorCallback) {
+            onError = errorCallback;
+        }
+
+        function setScriptTarget(scriptTarget: ScriptTarget) {
+            languageVersion = scriptTarget;
+        }
+
         function setTextPos(textPos: number) {
             pos = textPos;
             startPos = textPos;
             tokenPos = textPos;
             token = SyntaxKind.Unknown;
             precedingLineBreak = false;
+
+            tokenValue = undefined;
+            hasExtendedUnicodeEscape = false;
+            tokenIsUnterminated = false;
         }
-
-        setText(text);
-
-
-        return {
-            getStartPos: () => startPos,
-            getTextPos: () => pos,
-            getToken: () => token,
-            getTokenPos: () => tokenPos,
-            getTokenText: () => text.substring(tokenPos, pos),
-            getTokenValue: () => tokenValue,
-            hasExtendedUnicodeEscape: () => hasExtendedUnicodeEscape,
-            hasPrecedingLineBreak: () => precedingLineBreak,
-            isIdentifier: () => token === SyntaxKind.Identifier || token > SyntaxKind.LastReservedWord,
-            isReservedWord: () => token >= SyntaxKind.FirstReservedWord && token <= SyntaxKind.LastReservedWord,
-            isUnterminated: () => tokenIsUnterminated,
-            reScanGreaterToken,
-            reScanSlashToken,
-            reScanTemplateToken,
-            scan,
-            setText,
-            setTextPos,
-            tryScan,
-            lookAhead,
-        };
     }
 }

src/compiler/types.ts

@@ -1405,6 +1405,7 @@ module ts {
         BlockScopedBindingInLoop    = 0x00000100,
         EmitDecorate                = 0x00000200,  // Emit __decorate
         EmitParam                   = 0x00000400,  // Emit __param helper for decorators
+        LexicalModuleMergesWithClass = 0x00000800,  // Instantiated lexical module declaration is merged with a previous class declaration.
     }
 
     /* @internal */ 

src/compiler/utilities.ts

@@ -211,8 +211,10 @@ module ts {
             isCatchClauseVariableDeclaration(declaration);
     }
 
+    // Gets the nearest enclosing block scope container that has the provided node 
+    // as a descendant, that is not the provided node.
     export function getEnclosingBlockScopeContainer(node: Node): Node {
-        let current = node;
+        let current = node.parent;
         while (current) {
             if (isFunctionLike(current)) {
                 return current;
@@ -1165,6 +1167,13 @@ module ts {
         return node;
     }
 
+    export function createSynthesizedNodeArray(): NodeArray<any> {
+        var array = <NodeArray<any>>[];
+        array.pos = -1;
+        array.end = -1;
+        return array;
+    }
+
     export function createDiagnosticCollection(): DiagnosticCollection {
         let nonFileDiagnostics: Diagnostic[] = [];
         let fileDiagnostics: Map<Diagnostic[]> = {};
@@ -1612,6 +1621,55 @@ module ts {
         }
     }
 
+    export function modifierToFlag(token: SyntaxKind): NodeFlags {
+        switch (token) {
+            case SyntaxKind.StaticKeyword: return NodeFlags.Static;
+            case SyntaxKind.PublicKeyword: return NodeFlags.Public;
+            case SyntaxKind.ProtectedKeyword: return NodeFlags.Protected;
+            case SyntaxKind.PrivateKeyword: return NodeFlags.Private;
+            case SyntaxKind.ExportKeyword: return NodeFlags.Export;
+            case SyntaxKind.DeclareKeyword: return NodeFlags.Ambient;
+            case SyntaxKind.ConstKeyword: return NodeFlags.Const;
+            case SyntaxKind.DefaultKeyword: return NodeFlags.Default;
+        }
+        return 0;
+    }
+
+    export function isLeftHandSideExpression(expr: Expression): boolean {
+        if (expr) {
+            switch (expr.kind) {
+                case SyntaxKind.PropertyAccessExpression:
+                case SyntaxKind.ElementAccessExpression:
+                case SyntaxKind.NewExpression:
+                case SyntaxKind.CallExpression:
+                case SyntaxKind.TaggedTemplateExpression:
+                case SyntaxKind.ArrayLiteralExpression:
+                case SyntaxKind.ParenthesizedExpression:
+                case SyntaxKind.ObjectLiteralExpression:
+                case SyntaxKind.ClassExpression:
+                case SyntaxKind.FunctionExpression:
+                case SyntaxKind.Identifier:
+                case SyntaxKind.RegularExpressionLiteral:
+                case SyntaxKind.NumericLiteral:
+                case SyntaxKind.StringLiteral:
+                case SyntaxKind.NoSubstitutionTemplateLiteral:
+                case SyntaxKind.TemplateExpression:
+                case SyntaxKind.FalseKeyword:
+                case SyntaxKind.NullKeyword:
+                case SyntaxKind.ThisKeyword:
+                case SyntaxKind.TrueKeyword:
+                case SyntaxKind.SuperKeyword:
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+    export function isAssignmentOperator(token: SyntaxKind): boolean {
+        return token >= SyntaxKind.FirstAssignment && token <= SyntaxKind.LastAssignment;
+    }
+
     // Returns false if this heritage clause element's expression contains something unsupported
     // (i.e. not a name or dotted name).
     export function isSupportedHeritageClauseElement(node: HeritageClauseElement): boolean {
@@ -1855,4 +1913,4 @@ module ts {
 
         return createTextChangeRange(createTextSpanFromBounds(oldStartN, oldEndN), /*newLength:*/ newEndN - oldStartN);
     }
-}
+}

src/harness/compilerRunner.ts

@@ -253,6 +253,10 @@ class CompilerBaselineRunner extends RunnerBase {
             });
 
             it('Correct type baselines for ' + fileName, () => {
+                if (fileName.indexOf("APISample") >= 0) {
+                    return;
+                }
+
                 // NEWTODO: Type baselines
                 if (result.errors.length === 0) {
                     // The full walker simulates the types that you would get from doing a full 
@@ -270,29 +274,53 @@ class CompilerBaselineRunner extends RunnerBase {
                     // These types are equivalent, but depend on what order the compiler observed 
                     // certain parts of the program.
 
-                    var fullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ true);
-                    var pullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ false);
+                    let allFiles = toBeCompiled.concat(otherFiles).filter(file => !!program.getSourceFile(file.unitName));
 
-                    var fullTypes = generateTypes(fullWalker);
-                    var pullTypes = generateTypes(pullWalker);
+                    let fullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ true);
+                    let pullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ false);
 
-                    if (fullTypes !== pullTypes) {
-                        Harness.Baseline.runBaseline('Correct full expression types for ' + fileName, justName.replace(/\.ts/, '.types'), () => fullTypes);
-                        Harness.Baseline.runBaseline('Correct pull expression types for ' + fileName, justName.replace(/\.ts/, '.types.pull'), () => pullTypes);
-                    }
-                    else {
-                        Harness.Baseline.runBaseline('Correct expression types for ' + fileName, justName.replace(/\.ts/, '.types'), () => fullTypes);
+                    let fullResults: ts.Map<TypeWriterResult[]> = {};
+                    let pullResults: ts.Map<TypeWriterResult[]> = {};
+
+                    for (let sourceFile of allFiles) {
+                        fullResults[sourceFile.unitName] = fullWalker.getTypeAndSymbols(sourceFile.unitName);
+                        pullResults[sourceFile.unitName] = fullWalker.getTypeAndSymbols(sourceFile.unitName);
                     }
 
-                    function generateTypes(walker: TypeWriterWalker): string {
-                        var allFiles = toBeCompiled.concat(otherFiles).filter(file => !!program.getSourceFile(file.unitName));
-                        var typeLines: string[] = [];
-                        var typeMap: { [fileName: string]: { [lineNum: number]: string[]; } } = {};
+                    // Produce baselines.  The first gives the types for all expressions.
+                    // The second gives symbols for all identifiers.
+                    checkBaseLines(/*isSymbolBaseLine:*/ false);
+                    checkBaseLines(/*isSymbolBaseLine:*/ true);
+
+                    function checkBaseLines(isSymbolBaseLine: boolean) {
+                        let fullBaseLine = generateBaseLine(fullResults, isSymbolBaseLine);
+                        let pullBaseLine = generateBaseLine(pullResults, isSymbolBaseLine);
+
+                        let fullExtension = isSymbolBaseLine ? '.symbols' : '.types';
+                        let pullExtension = isSymbolBaseLine ? '.symbols.pull' : '.types.pull';
+
+                        if (fullBaseLine !== pullBaseLine) {
+                            Harness.Baseline.runBaseline('Correct full information for ' + fileName, justName.replace(/\.ts/, fullExtension), () => fullBaseLine);
+                            Harness.Baseline.runBaseline('Correct pull information for ' + fileName, justName.replace(/\.ts/, pullExtension), () => pullBaseLine);
+                        }
+                        else {
+                            Harness.Baseline.runBaseline('Correct information for ' + fileName, justName.replace(/\.ts/, fullExtension), () => fullBaseLine);
+                        }
+                    }
+
+                    function generateBaseLine(typeWriterResults: ts.Map<TypeWriterResult[]>, isSymbolBaseline: boolean): string {
+                        let typeLines: string[] = [];
+                        let typeMap: { [fileName: string]: { [lineNum: number]: string[]; } } = {};
 
                         allFiles.forEach(file => {
                             var codeLines = file.content.split('\n');
-                            walker.getTypes(file.unitName).forEach(result => {
-                                var formattedLine = result.sourceText.replace(/\r?\n/g, "") + " : " + result.type;
+                            typeWriterResults[file.unitName].forEach(result => {
+                                if (isSymbolBaseline && !result.symbol) {
+                                    return;
+                                }
+
+                                var typeOrSymbolString = isSymbolBaseline ? result.symbol : result.type;
+                                var formattedLine = result.sourceText.replace(/\r?\n/g, "") + " : " + typeOrSymbolString;
                                 if (!typeMap[file.unitName]) {
                                     typeMap[file.unitName] = {};
                                 }
@@ -316,11 +344,13 @@ class CompilerBaselineRunner extends RunnerBase {
                                             typeLines.push('>' + ty + '\r\n');
                                         });
                                         if (i + 1 < codeLines.length && (codeLines[i + 1].match(/^\s*[{|}]\s*$/) || codeLines[i + 1].trim() === '')) {
-                                        } else {
+                                        }
+                                        else {
                                             typeLines.push('\r\n');
                                         }
                                     }
-                                } else {
+                                }
+                                else {
                                     typeLines.push('No type information for this code.');
                                 }
                             }

src/harness/typeWriter.ts

@@ -3,6 +3,7 @@ interface TypeWriterResult {
     syntaxKind: number;
     sourceText: string;
     type: string;
+    symbol: string;
 }
 
 class TypeWriterWalker {
@@ -19,7 +20,7 @@ class TypeWriterWalker {
             : program.getTypeChecker();
     }
 
-    public getTypes(fileName: string): TypeWriterResult[] {
+    public getTypeAndSymbols(fileName: string): TypeWriterResult[] {
         var sourceFile = this.program.getSourceFile(fileName);
         this.currentSourceFile = sourceFile;
         this.results = [];
@@ -45,8 +46,9 @@ class TypeWriterWalker {
         var symbol = this.checker.getSymbolAtLocation(node);
 
         var typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation);
+        var symbolString: string;
         if (symbol) {
-            var symbolString = "Symbol(" + this.checker.symbolToString(symbol, node.parent);
+            symbolString = "Symbol(" + this.checker.symbolToString(symbol, node.parent);
             if (symbol.declarations) {
                 for (let declaration of symbol.declarations) {
                     symbolString += ", ";
@@ -56,15 +58,14 @@ class TypeWriterWalker {
                 }
             }
             symbolString += ")";
-
-            typeString += ", " + symbolString;
         }
 
         this.results.push({
             line: lineAndCharacter.line,
             syntaxKind: node.kind,
             sourceText: sourceText,
-            type: typeString
+            type: typeString,
+            symbol: symbolString
         });
     }
 }

src/lib/scriptHost.d.ts

@@ -21,13 +21,16 @@ interface TextStreamBase {
      * The column number of the current character position in an input stream.
      */
     Column: number;
+
     /**
      * The current line number in an input stream.
      */
     Line: number;
+
     /**
      * Closes a text stream.
-     * It is not necessary to close standard streams; they close automatically when the process ends. If you close a standard stream, be aware that any other pointers to that standard stream become invalid.
+     * It is not necessary to close standard streams; they close automatically when the process ends. If 
+     * you close a standard stream, be aware that any other pointers to that standard stream become invalid.
      */
     Close(): void;
 }
@@ -37,10 +40,12 @@ interface TextStreamWriter extends TextStreamBase {
      * Sends a string to an output stream.
      */
     Write(s: string): void;
+
     /**
      * Sends a specified number of blank lines (newline characters) to an output stream.
      */
     WriteBlankLines(intLines: number): void;
+
     /**
      * Sends a string followed by a newline character to an output stream.
      */
@@ -49,37 +54,43 @@ interface TextStreamWriter extends TextStreamBase {
 
 interface TextStreamReader extends TextStreamBase {
     /**
-     * Returns a specified number of characters from an input stream, beginning at the current pointer position.
+     * Returns a specified number of characters from an input stream, starting at the current pointer position.
      * Does not return until the ENTER key is pressed.
      * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
      */
     Read(characters: number): string;
+
     /**
      * Returns all characters from an input stream.
      * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
      */
     ReadAll(): string;
+
     /**
      * Returns an entire line from an input stream.
      * Although this method extracts the newline character, it does not add it to the returned string.
      * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
      */
     ReadLine(): string;
+
     /**
      * Skips a specified number of characters when reading from an input text stream.
      * Can only be used on a stream in reading mode; causes an error in writing or appending mode.
      * @param characters Positive number of characters to skip forward. (Backward skipping is not supported.)
      */
     Skip(characters: number): void;
+
     /**
      * Skips the next line when reading from an input text stream.
      * Can only be used on a stream in reading mode, not writing or appending mode.
      */
     SkipLine(): void;
+
     /**
      * Indicates whether the stream pointer position is at the end of a line.
      */
     AtEndOfLine: boolean;
+
     /**
      * Indicates whether the stream pointer position is at the end of a stream.
      */
@@ -88,85 +99,180 @@ interface TextStreamReader extends TextStreamBase {
 
 declare var WScript: {
     /**
-    * Outputs text to either a message box (under WScript.exe) or the command console window followed by a newline (under CScript.ext).
+    * Outputs text to either a message box (under WScript.exe) or the command console window followed by
+    * a newline (under CScript.exe).
     */
     Echo(s: any): void;
+
     /**
      * Exposes the write-only error output stream for the current script.
      * Can be accessed only while using CScript.exe.
      */
     StdErr: TextStreamWriter;
+
     /**
      * Exposes the write-only output stream for the current script.
      * Can be accessed only while using CScript.exe.
      */
     StdOut: TextStreamWriter;
     Arguments: { length: number; Item(n: number): string; };
+
     /**
      *  The full path of the currently running script.
      */
     ScriptFullName: string;
+
     /**
      * Forces the script to stop immediately, with an optional exit code.
      */
     Quit(exitCode?: number): number;
+
     /**
      * The Windows Script Host build version number.
      */
     BuildVersion: number;
+
     /**
      * Fully qualified path of the host executable.
      */
     FullName: string;
+
     /**
      * Gets/sets the script mode - interactive(true) or batch(false).
      */
     Interactive: boolean;
+
     /**
      * The name of the host executable (WScript.exe or CScript.exe).
      */
     Name: string;
+
     /**
      * Path of the directory containing the host executable.
      */
     Path: string;
+
     /**
      * The filename of the currently running script.
      */
     ScriptName: string;
+
     /**
      * Exposes the read-only input stream for the current script.
      * Can be accessed only while using CScript.exe.
      */
     StdIn: TextStreamReader;
+
     /**
      * Windows Script Host version
      */
     Version: string;
+
     /**
      * Connects a COM object's event sources to functions named with a given prefix, in the form prefix_event.
      */
     ConnectObject(objEventSource: any, strPrefix: string): void;
+
     /**
      * Creates a COM object.
      * @param strProgiID
      * @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
      */
     CreateObject(strProgID: string, strPrefix?: string): any;
+
     /**
      * Disconnects a COM object from its event sources.
      */
     DisconnectObject(obj: any): void;
+
     /**
      * Retrieves an existing object with the specified ProgID from memory, or creates a new one from a file.
-     * @param strPathname Fully qualified path to the file containing the object persisted to disk. For objects in memory, pass a zero-length string.
+     * @param strPathname Fully qualified path to the file containing the object persisted to disk.
+     *                       For objects in memory, pass a zero-length string.
      * @param strProgID
      * @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
      */
     GetObject(strPathname: string, strProgID?: string, strPrefix?: string): any;
+
     /**
      * Suspends script execution for a specified length of time, then continues execution.
      * @param intTime Interval (in milliseconds) to suspend script execution.
      */
     Sleep(intTime: number): void;
 };
+
+/**
+ * Allows enumerating over a COM collection, which may not have indexed item access.
+ */
+interface Enumerator<T> {
+    /**
+     * Returns true if the current item is the last one in the collection, or the collection is empty,
+     * or the current item is undefined.
+     */
+    atEnd(): boolean;
+
+    /**
+     * Returns the current item in the collection
+     */
+    item(): T;
+
+    /**
+     * Resets the current item in the collection to the first item. If there are no items in the collection,
+     * the current item is set to undefined.
+     */
+    moveFirst(): void;
+
+    /**
+     * Moves the current item to the next item in the collection. If the enumerator is at the end of
+     * the collection or the collection is empty, the current item is set to undefined.
+     */
+    moveNext(): void;
+}
+
+interface EnumeratorConstructor {
+    new <T>(collection: any): Enumerator<T>;
+    new (collection: any): Enumerator<any>;
+}
+
+declare var Enumerator: EnumeratorConstructor;
+
+/**
+ * Enables reading from a COM safe array, which might have an alternate lower bound, or multiple dimensions.
+ */
+interface VBArray<T> {
+    /**
+     * Returns the number of dimensions (1-based).
+     */
+    dimensions(): number;
+
+    /**
+     * Takes an index for each dimension in the array, and returns the item at the corresponding location.
+     */
+    getItem(dimension1Index: number, ...dimensionNIndexes: number[]): T;
+
+    /**
+     * Returns the smallest available index for a given dimension.
+     * @param dimension 1-based dimension (defaults to 1)
+     */
+    lbound(dimension?: number): number;
+
+    /**
+     * Returns the largest available index for a given dimension.
+     * @param dimension 1-based dimension (defaults to 1)
+     */
+    ubound(dimension?: number): number;
+
+    /**
+     * Returns a Javascript array with all the elements in the VBArray. If there are multiple dimensions,
+     * each successive dimension is appended to the end of the array.
+     * Example: [[1,2,3],[4,5,6]] becomes [1,2,3,4,5,6]
+     */
+    toArray(): T[];
+}
+
+interface VBArrayConstructor {
+    new <T>(safeArray: any): VBArray<T>;
+    new (safeArray: any): VBArray<any>;
+}
+
+declare var VBArray: VBArrayConstructor;

tests/baselines/reference/2dArrays.symbols

@@ -0,0 +1,38 @@
+=== tests/cases/compiler/2dArrays.ts ===
+class Cell {
+>Cell : Symbol(Cell, Decl(2dArrays.ts, 0, 0))
+}
+
+class Ship {
+>Ship : Symbol(Ship, Decl(2dArrays.ts, 1, 1))
+
+    isSunk: boolean;
+>isSunk : Symbol(isSunk, Decl(2dArrays.ts, 3, 12))
+}
+
+class Board {
+>Board : Symbol(Board, Decl(2dArrays.ts, 5, 1))
+
+    ships: Ship[];
+>ships : Symbol(ships, Decl(2dArrays.ts, 7, 13))
+>Ship : Symbol(Ship, Decl(2dArrays.ts, 1, 1))
+
+    cells: Cell[];
+>cells : Symbol(cells, Decl(2dArrays.ts, 8, 18))
+>Cell : Symbol(Cell, Decl(2dArrays.ts, 0, 0))
+
+    private allShipsSunk() {
+>allShipsSunk : Symbol(allShipsSunk, Decl(2dArrays.ts, 9, 18))
+
+        return this.ships.every(function (val) { return val.isSunk; });
+>this.ships.every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>this.ships : Symbol(ships, Decl(2dArrays.ts, 7, 13))
+>this : Symbol(Board, Decl(2dArrays.ts, 5, 1))
+>ships : Symbol(ships, Decl(2dArrays.ts, 7, 13))
+>every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>val : Symbol(val, Decl(2dArrays.ts, 12, 42))
+>val.isSunk : Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
+>val : Symbol(val, Decl(2dArrays.ts, 12, 42))
+>isSunk : Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
+    }    
+}

tests/baselines/reference/2dArrays.types

@@ -1,40 +1,40 @@
 === tests/cases/compiler/2dArrays.ts ===
 class Cell {
->Cell : Cell, Symbol(Cell, Decl(2dArrays.ts, 0, 0))
+>Cell : Cell
 }
 
 class Ship {
->Ship : Ship, Symbol(Ship, Decl(2dArrays.ts, 1, 1))
+>Ship : Ship
 
     isSunk: boolean;
->isSunk : boolean, Symbol(isSunk, Decl(2dArrays.ts, 3, 12))
+>isSunk : boolean
 }
 
 class Board {
->Board : Board, Symbol(Board, Decl(2dArrays.ts, 5, 1))
+>Board : Board
 
     ships: Ship[];
->ships : Ship[], Symbol(ships, Decl(2dArrays.ts, 7, 13))
->Ship : Ship, Symbol(Ship, Decl(2dArrays.ts, 1, 1))
+>ships : Ship[]
+>Ship : Ship
 
     cells: Cell[];
->cells : Cell[], Symbol(cells, Decl(2dArrays.ts, 8, 18))
->Cell : Cell, Symbol(Cell, Decl(2dArrays.ts, 0, 0))
+>cells : Cell[]
+>Cell : Cell
 
     private allShipsSunk() {
->allShipsSunk : () => boolean, Symbol(allShipsSunk, Decl(2dArrays.ts, 9, 18))
+>allShipsSunk : () => boolean
 
         return this.ships.every(function (val) { return val.isSunk; });
 >this.ships.every(function (val) { return val.isSunk; }) : boolean
->this.ships.every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean, Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
->this.ships : Ship[], Symbol(ships, Decl(2dArrays.ts, 7, 13))
->this : Board, Symbol(Board, Decl(2dArrays.ts, 5, 1))
->ships : Ship[], Symbol(ships, Decl(2dArrays.ts, 7, 13))
->every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean, Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>this.ships.every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
+>this.ships : Ship[]
+>this : Board
+>ships : Ship[]
+>every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
 >function (val) { return val.isSunk; } : (val: Ship) => boolean
->val : Ship, Symbol(val, Decl(2dArrays.ts, 12, 42))
->val.isSunk : boolean, Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
->val : Ship, Symbol(val, Decl(2dArrays.ts, 12, 42))
->isSunk : boolean, Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
+>val : Ship
+>val.isSunk : boolean
+>val : Ship
+>isSunk : boolean
     }    
 }

tests/baselines/reference/APISample_compile.types

@@ -1,168 +0,0 @@
-=== tests/cases/compiler/APISample_compile.ts ===
-
-/*
- * Note: This test is a public API sample. The sample sources can be found 
-         at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#a-minimal-compiler
- *       Please log a "breaking change" issue for any API breaking change affecting this issue
- */
-
-declare var process: any;
->process : any, Symbol(process, Decl(APISample_compile.ts, 7, 11))
-
-declare var console: any;
->console : any, Symbol(console, Decl(APISample_compile.ts, 8, 11))
-
-declare var os: any;
->os : any, Symbol(os, Decl(APISample_compile.ts, 9, 11))
-
-import ts = require("typescript");
->ts : typeof ts, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
-
-export function compile(fileNames: string[], options: ts.CompilerOptions): void {
->compile : (fileNames: string[], options: ts.CompilerOptions) => void, Symbol(compile, Decl(APISample_compile.ts, 11, 34))
->fileNames : string[], Symbol(fileNames, Decl(APISample_compile.ts, 13, 24))
->options : ts.CompilerOptions, Symbol(options, Decl(APISample_compile.ts, 13, 44))
->ts : any, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
->CompilerOptions : ts.CompilerOptions, Symbol(ts.CompilerOptions, Decl(typescript.d.ts, 1074, 5))
-
-    var program = ts.createProgram(fileNames, options);
->program : ts.Program, Symbol(program, Decl(APISample_compile.ts, 14, 7))
->ts.createProgram(fileNames, options) : ts.Program
->ts.createProgram : (rootNames: string[], options: ts.CompilerOptions, host?: ts.CompilerHost) => ts.Program, Symbol(ts.createProgram, Decl(typescript.d.ts, 1229, 113))
->ts : typeof ts, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
->createProgram : (rootNames: string[], options: ts.CompilerOptions, host?: ts.CompilerHost) => ts.Program, Symbol(ts.createProgram, Decl(typescript.d.ts, 1229, 113))
->fileNames : string[], Symbol(fileNames, Decl(APISample_compile.ts, 13, 24))
->options : ts.CompilerOptions, Symbol(options, Decl(APISample_compile.ts, 13, 44))
-
-    var emitResult = program.emit();
->emitResult : ts.EmitResult, Symbol(emitResult, Decl(APISample_compile.ts, 15, 7))
->program.emit() : ts.EmitResult
->program.emit : (targetSourceFile?: ts.SourceFile, writeFile?: ts.WriteFileCallback) => ts.EmitResult, Symbol(ts.Program.emit, Decl(typescript.d.ts, 767, 39))
->program : ts.Program, Symbol(program, Decl(APISample_compile.ts, 14, 7))
->emit : (targetSourceFile?: ts.SourceFile, writeFile?: ts.WriteFileCallback) => ts.EmitResult, Symbol(ts.Program.emit, Decl(typescript.d.ts, 767, 39))
-
-    var allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
->allDiagnostics : ts.Diagnostic[], Symbol(allDiagnostics, Decl(APISample_compile.ts, 17, 7))
->ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics) : ts.Diagnostic[]
->ts.getPreEmitDiagnostics(program).concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
->ts.getPreEmitDiagnostics(program) : ts.Diagnostic[]
->ts.getPreEmitDiagnostics : (program: ts.Program) => ts.Diagnostic[], Symbol(ts.getPreEmitDiagnostics, Decl(typescript.d.ts, 1227, 98))
->ts : typeof ts, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
->getPreEmitDiagnostics : (program: ts.Program) => ts.Diagnostic[], Symbol(ts.getPreEmitDiagnostics, Decl(typescript.d.ts, 1227, 98))
->program : ts.Program, Symbol(program, Decl(APISample_compile.ts, 14, 7))
->concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
->emitResult.diagnostics : ts.Diagnostic[], Symbol(ts.EmitResult.diagnostics, Decl(typescript.d.ts, 820, 29))
->emitResult : ts.EmitResult, Symbol(emitResult, Decl(APISample_compile.ts, 15, 7))
->diagnostics : ts.Diagnostic[], Symbol(ts.EmitResult.diagnostics, Decl(typescript.d.ts, 820, 29))
-
-    allDiagnostics.forEach(diagnostic => {
->allDiagnostics.forEach(diagnostic => {        var { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);        var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');        console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);    }) : void
->allDiagnostics.forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->allDiagnostics : ts.Diagnostic[], Symbol(allDiagnostics, Decl(APISample_compile.ts, 17, 7))
->forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->diagnostic => {        var { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);        var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');        console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);    } : (diagnostic: ts.Diagnostic) => void
->diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
-
-        var { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
->line : number, Symbol(line, Decl(APISample_compile.ts, 20, 13))
->character : number, Symbol(character, Decl(APISample_compile.ts, 20, 19))
->diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start) : ts.LineAndCharacter
->diagnostic.file.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1290, 26))
->diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
->diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
->file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
->getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1290, 26))
->diagnostic.start : number, Symbol(ts.Diagnostic.start, Decl(typescript.d.ts, 1063, 25))
->diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
->start : number, Symbol(ts.Diagnostic.start, Decl(typescript.d.ts, 1063, 25))
-
-        var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
->message : string, Symbol(message, Decl(APISample_compile.ts, 21, 11))
->ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n') : string
->ts.flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string, Symbol(ts.flattenDiagnosticMessageText, Decl(typescript.d.ts, 1228, 67))
->ts : typeof ts, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
->flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string, Symbol(ts.flattenDiagnosticMessageText, Decl(typescript.d.ts, 1228, 67))
->diagnostic.messageText : string | ts.DiagnosticMessageChain, Symbol(ts.Diagnostic.messageText, Decl(typescript.d.ts, 1065, 23))
->diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
->messageText : string | ts.DiagnosticMessageChain, Symbol(ts.Diagnostic.messageText, Decl(typescript.d.ts, 1065, 23))
->'\n' : string
-
-        console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
->console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`) : any
->console.log : any
->console : any, Symbol(console, Decl(APISample_compile.ts, 8, 11))
->log : any
->`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}` : string
->diagnostic.file.fileName : string, Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
->diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
->diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
->file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
->fileName : string, Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
->line + 1 : number
->line : number, Symbol(line, Decl(APISample_compile.ts, 20, 13))
->1 : number
->character + 1 : number
->character : number, Symbol(character, Decl(APISample_compile.ts, 20, 19))
->1 : number
->message : string, Symbol(message, Decl(APISample_compile.ts, 21, 11))
-
-    });
-
-    var exitCode = emitResult.emitSkipped ? 1 : 0;
->exitCode : number, Symbol(exitCode, Decl(APISample_compile.ts, 25, 7))
->emitResult.emitSkipped ? 1 : 0 : number
->emitResult.emitSkipped : boolean, Symbol(ts.EmitResult.emitSkipped, Decl(typescript.d.ts, 819, 26))
->emitResult : ts.EmitResult, Symbol(emitResult, Decl(APISample_compile.ts, 15, 7))
->emitSkipped : boolean, Symbol(ts.EmitResult.emitSkipped, Decl(typescript.d.ts, 819, 26))
->1 : number
->0 : number
-
-    console.log(`Process exiting with code '${exitCode}'.`);
->console.log(`Process exiting with code '${exitCode}'.`) : any
->console.log : any
->console : any, Symbol(console, Decl(APISample_compile.ts, 8, 11))
->log : any
->`Process exiting with code '${exitCode}'.` : string
->exitCode : number, Symbol(exitCode, Decl(APISample_compile.ts, 25, 7))
-
-    process.exit(exitCode);
->process.exit(exitCode) : any
->process.exit : any
->process : any, Symbol(process, Decl(APISample_compile.ts, 7, 11))
->exit : any
->exitCode : number, Symbol(exitCode, Decl(APISample_compile.ts, 25, 7))
-}
-
-compile(process.argv.slice(2), {
->compile(process.argv.slice(2), {    noEmitOnError: true, noImplicitAny: true,    target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS}) : void
->compile : (fileNames: string[], options: ts.CompilerOptions) => void, Symbol(compile, Decl(APISample_compile.ts, 11, 34))
->process.argv.slice(2) : any
->process.argv.slice : any
->process.argv : any
->process : any, Symbol(process, Decl(APISample_compile.ts, 7, 11))
->argv : any
->slice : any
->2 : number
->{    noEmitOnError: true, noImplicitAny: true,    target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS} : { [x: string]: boolean | ts.ScriptTarget | ts.ModuleKind; noEmitOnError: boolean; noImplicitAny: boolean; target: ts.ScriptTarget; module: ts.ModuleKind; }
-
-    noEmitOnError: true, noImplicitAny: true,
->noEmitOnError : boolean, Symbol(noEmitOnError, Decl(APISample_compile.ts, 30, 32))
->true : boolean
->noImplicitAny : boolean, Symbol(noImplicitAny, Decl(APISample_compile.ts, 31, 24))
->true : boolean
-
-    target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS
->target : ts.ScriptTarget, Symbol(target, Decl(APISample_compile.ts, 31, 45))
->ts.ScriptTarget.ES5 : ts.ScriptTarget, Symbol(ts.ScriptTarget.ES5, Decl(typescript.d.ts, 1117, 16))
->ts.ScriptTarget : typeof ts.ScriptTarget, Symbol(ts.ScriptTarget, Decl(typescript.d.ts, 1115, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
->ScriptTarget : typeof ts.ScriptTarget, Symbol(ts.ScriptTarget, Decl(typescript.d.ts, 1115, 5))
->ES5 : ts.ScriptTarget, Symbol(ts.ScriptTarget.ES5, Decl(typescript.d.ts, 1117, 16))
->module : ts.ModuleKind, Symbol(module, Decl(APISample_compile.ts, 32, 32))
->ts.ModuleKind.CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
->ts.ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
->ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
->CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
-
-});

tests/baselines/reference/APISample_linter.types

@@ -1,312 +0,0 @@
-=== tests/cases/compiler/APISample_linter.ts ===
-
-/*
- * Note: This test is a public API sample. The sample sources can be found 
-         at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#traversing-the-ast-with-a-little-linter
- *       Please log a "breaking change" issue for any API breaking change affecting this issue
- */
-
-declare var process: any;
->process : any, Symbol(process, Decl(APISample_linter.ts, 7, 11))
-
-declare var console: any;
->console : any, Symbol(console, Decl(APISample_linter.ts, 8, 11))
-
-declare var readFileSync: any;
->readFileSync : any, Symbol(readFileSync, Decl(APISample_linter.ts, 9, 11))
-
-import * as ts from "typescript";
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
-
-export function delint(sourceFile: ts.SourceFile) {
->delint : (sourceFile: ts.SourceFile) => void, Symbol(delint, Decl(APISample_linter.ts, 11, 33))
->sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 13, 23))
->ts : any, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->SourceFile : ts.SourceFile, Symbol(ts.SourceFile, Decl(typescript.d.ts, 740, 5), Decl(typescript.d.ts, 1289, 5))
-
-    delintNode(sourceFile);
->delintNode(sourceFile) : void
->delintNode : (node: ts.Node) => void, Symbol(delintNode, Decl(APISample_linter.ts, 14, 27))
->sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 13, 23))
-
-    function delintNode(node: ts.Node) {
->delintNode : (node: ts.Node) => void, Symbol(delintNode, Decl(APISample_linter.ts, 14, 27))
->node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
->ts : any, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->Node : ts.Node, Symbol(ts.Node, Decl(typescript.d.ts, 296, 5), Decl(typescript.d.ts, 1249, 32))
-
-        switch (node.kind) {
->node.kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
->node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
->kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
-
-            case ts.SyntaxKind.ForStatement:
->ts.SyntaxKind.ForStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.ForStatement, Decl(typescript.d.ts, 209, 29))
->ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ForStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.ForStatement, Decl(typescript.d.ts, 209, 29))
-
-            case ts.SyntaxKind.ForInStatement:
->ts.SyntaxKind.ForInStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.ForInStatement, Decl(typescript.d.ts, 210, 27))
->ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ForInStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.ForInStatement, Decl(typescript.d.ts, 210, 27))
-
-            case ts.SyntaxKind.WhileStatement:
->ts.SyntaxKind.WhileStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.WhileStatement, Decl(typescript.d.ts, 208, 26))
->ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->WhileStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.WhileStatement, Decl(typescript.d.ts, 208, 26))
-
-            case ts.SyntaxKind.DoStatement:
->ts.SyntaxKind.DoStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.DoStatement, Decl(typescript.d.ts, 207, 26))
->ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->DoStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.DoStatement, Decl(typescript.d.ts, 207, 26))
-
-                if ((<ts.IterationStatement>node).statement.kind !== ts.SyntaxKind.Block) {
->(<ts.IterationStatement>node).statement.kind !== ts.SyntaxKind.Block : boolean
->(<ts.IterationStatement>node).statement.kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
->(<ts.IterationStatement>node).statement : ts.Statement, Symbol(ts.IterationStatement.statement, Decl(typescript.d.ts, 589, 52))
->(<ts.IterationStatement>node) : ts.IterationStatement
-><ts.IterationStatement>node : ts.IterationStatement
->ts : any, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->IterationStatement : ts.IterationStatement, Symbol(ts.IterationStatement, Decl(typescript.d.ts, 588, 5))
->node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
->statement : ts.Statement, Symbol(ts.IterationStatement.statement, Decl(typescript.d.ts, 589, 52))
->kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
->ts.SyntaxKind.Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
->ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
-
-                    report(node, "A looping statement's contents should be wrapped in a block body.");
->report(node, "A looping statement's contents should be wrapped in a block body.") : void
->report : (node: ts.Node, message: string) => void, Symbol(report, Decl(APISample_linter.ts, 48, 5))
->node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
->"A looping statement's contents should be wrapped in a block body." : string
-                }
-                break;
-
-            case ts.SyntaxKind.IfStatement:
->ts.SyntaxKind.IfStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.IfStatement, Decl(typescript.d.ts, 206, 34))
->ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->IfStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.IfStatement, Decl(typescript.d.ts, 206, 34))
-
-                let ifStatement = (<ts.IfStatement>node);
->ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
->(<ts.IfStatement>node) : ts.IfStatement
-><ts.IfStatement>node : ts.IfStatement
->ts : any, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->IfStatement : ts.IfStatement, Symbol(ts.IfStatement, Decl(typescript.d.ts, 583, 5))
->node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
-
-                if (ifStatement.thenStatement.kind !== ts.SyntaxKind.Block) {
->ifStatement.thenStatement.kind !== ts.SyntaxKind.Block : boolean
->ifStatement.thenStatement.kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
->ifStatement.thenStatement : ts.Statement, Symbol(ts.IfStatement.thenStatement, Decl(typescript.d.ts, 585, 31))
->ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
->thenStatement : ts.Statement, Symbol(ts.IfStatement.thenStatement, Decl(typescript.d.ts, 585, 31))
->kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
->ts.SyntaxKind.Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
->ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
-
-                    report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body.");
->report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body.") : void
->report : (node: ts.Node, message: string) => void, Symbol(report, Decl(APISample_linter.ts, 48, 5))
->ifStatement.thenStatement : ts.Statement, Symbol(ts.IfStatement.thenStatement, Decl(typescript.d.ts, 585, 31))
->ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
->thenStatement : ts.Statement, Symbol(ts.IfStatement.thenStatement, Decl(typescript.d.ts, 585, 31))
->"An if statement's contents should be wrapped in a block body." : string
-                }
-                if (ifStatement.elseStatement &&
->ifStatement.elseStatement &&                    ifStatement.elseStatement.kind !== ts.SyntaxKind.Block &&                    ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement : boolean
->ifStatement.elseStatement &&                    ifStatement.elseStatement.kind !== ts.SyntaxKind.Block : boolean
->ifStatement.elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
->ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
->elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
-
-                    ifStatement.elseStatement.kind !== ts.SyntaxKind.Block &&
->ifStatement.elseStatement.kind !== ts.SyntaxKind.Block : boolean
->ifStatement.elseStatement.kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
->ifStatement.elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
->ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
->elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
->kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
->ts.SyntaxKind.Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
->ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
-
-                    ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement) {
->ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement : boolean
->ifStatement.elseStatement.kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
->ifStatement.elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
->ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
->elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
->kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
->ts.SyntaxKind.IfStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.IfStatement, Decl(typescript.d.ts, 206, 34))
->ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->IfStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.IfStatement, Decl(typescript.d.ts, 206, 34))
-
-                    report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body.");
->report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body.") : void
->report : (node: ts.Node, message: string) => void, Symbol(report, Decl(APISample_linter.ts, 48, 5))
->ifStatement.elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
->ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
->elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
->"An else statement's contents should be wrapped in a block body." : string
-                }
-                break;
-
-            case ts.SyntaxKind.BinaryExpression:
->ts.SyntaxKind.BinaryExpression : ts.SyntaxKind, Symbol(ts.SyntaxKind.BinaryExpression, Decl(typescript.d.ts, 192, 37))
->ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->BinaryExpression : ts.SyntaxKind, Symbol(ts.SyntaxKind.BinaryExpression, Decl(typescript.d.ts, 192, 37))
-
-                let op = (<ts.BinaryExpression>node).operatorToken.kind;
->op : ts.SyntaxKind, Symbol(op, Decl(APISample_linter.ts, 40, 19))
->(<ts.BinaryExpression>node).operatorToken.kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
->(<ts.BinaryExpression>node).operatorToken : ts.Node, Symbol(ts.BinaryExpression.operatorToken, Decl(typescript.d.ts, 497, 25))
->(<ts.BinaryExpression>node) : ts.BinaryExpression
-><ts.BinaryExpression>node : ts.BinaryExpression
->ts : any, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->BinaryExpression : ts.BinaryExpression, Symbol(ts.BinaryExpression, Decl(typescript.d.ts, 495, 5))
->node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
->operatorToken : ts.Node, Symbol(ts.BinaryExpression.operatorToken, Decl(typescript.d.ts, 497, 25))
->kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
-
-                if (op === ts.SyntaxKind.EqualsEqualsToken || op == ts.SyntaxKind.ExclamationEqualsToken) {
->op === ts.SyntaxKind.EqualsEqualsToken || op == ts.SyntaxKind.ExclamationEqualsToken : boolean
->op === ts.SyntaxKind.EqualsEqualsToken : boolean
->op : ts.SyntaxKind, Symbol(op, Decl(APISample_linter.ts, 40, 19))
->ts.SyntaxKind.EqualsEqualsToken : ts.SyntaxKind, Symbol(ts.SyntaxKind.EqualsEqualsToken, Decl(typescript.d.ts, 51, 36))
->ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->EqualsEqualsToken : ts.SyntaxKind, Symbol(ts.SyntaxKind.EqualsEqualsToken, Decl(typescript.d.ts, 51, 36))
->op == ts.SyntaxKind.ExclamationEqualsToken : boolean
->op : ts.SyntaxKind, Symbol(op, Decl(APISample_linter.ts, 40, 19))
->ts.SyntaxKind.ExclamationEqualsToken : ts.SyntaxKind, Symbol(ts.SyntaxKind.ExclamationEqualsToken, Decl(typescript.d.ts, 52, 31))
->ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
->ExclamationEqualsToken : ts.SyntaxKind, Symbol(ts.SyntaxKind.ExclamationEqualsToken, Decl(typescript.d.ts, 52, 31))
-
-                    report(node, "Use '===' and '!=='.")
->report(node, "Use '===' and '!=='.") : void
->report : (node: ts.Node, message: string) => void, Symbol(report, Decl(APISample_linter.ts, 48, 5))
->node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
->"Use '===' and '!=='." : string
-                }
-                break;
-        }
-
-        ts.forEachChild(node, delintNode);
->ts.forEachChild(node, delintNode) : void
->ts.forEachChild : <T>(node: ts.Node, cbNode: (node: ts.Node) => T, cbNodeArray?: (nodes: ts.Node[]) => T) => T, Symbol(ts.forEachChild, Decl(typescript.d.ts, 1214, 48))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->forEachChild : <T>(node: ts.Node, cbNode: (node: ts.Node) => T, cbNodeArray?: (nodes: ts.Node[]) => T) => T, Symbol(ts.forEachChild, Decl(typescript.d.ts, 1214, 48))
->node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
->delintNode : (node: ts.Node) => void, Symbol(delintNode, Decl(APISample_linter.ts, 14, 27))
-    }
-
-    function report(node: ts.Node, message: string) {
->report : (node: ts.Node, message: string) => void, Symbol(report, Decl(APISample_linter.ts, 48, 5))
->node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 50, 20))
->ts : any, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->Node : ts.Node, Symbol(ts.Node, Decl(typescript.d.ts, 296, 5), Decl(typescript.d.ts, 1249, 32))
->message : string, Symbol(message, Decl(APISample_linter.ts, 50, 34))
-
-        let { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
->line : number, Symbol(line, Decl(APISample_linter.ts, 51, 13))
->character : number, Symbol(character, Decl(APISample_linter.ts, 51, 19))
->sourceFile.getLineAndCharacterOfPosition(node.getStart()) : ts.LineAndCharacter
->sourceFile.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1290, 26))
->sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 13, 23))
->getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1290, 26))
->node.getStart() : number
->node.getStart : (sourceFile?: ts.SourceFile) => number, Symbol(ts.Node.getStart, Decl(typescript.d.ts, 1254, 53))
->node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 50, 20))
->getStart : (sourceFile?: ts.SourceFile) => number, Symbol(ts.Node.getStart, Decl(typescript.d.ts, 1254, 53))
-
-        console.log(`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}`);
->console.log(`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}`) : any
->console.log : any
->console : any, Symbol(console, Decl(APISample_linter.ts, 8, 11))
->log : any
->`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}` : string
->sourceFile.fileName : string, Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
->sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 13, 23))
->fileName : string, Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
->line + 1 : number
->line : number, Symbol(line, Decl(APISample_linter.ts, 51, 13))
->1 : number
->character + 1 : number
->character : number, Symbol(character, Decl(APISample_linter.ts, 51, 19))
->1 : number
->message : string, Symbol(message, Decl(APISample_linter.ts, 50, 34))
-    }
-}
-
-const fileNames = process.argv.slice(2);
->fileNames : any, Symbol(fileNames, Decl(APISample_linter.ts, 56, 5))
->process.argv.slice(2) : any
->process.argv.slice : any
->process.argv : any
->process : any, Symbol(process, Decl(APISample_linter.ts, 7, 11))
->argv : any
->slice : any
->2 : number
-
-fileNames.forEach(fileName => {
->fileNames.forEach(fileName => {    // Parse a file    let sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true);    // delint it    delint(sourceFile);}) : any
->fileNames.forEach : any
->fileNames : any, Symbol(fileNames, Decl(APISample_linter.ts, 56, 5))
->forEach : any
->fileName => {    // Parse a file    let sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true);    // delint it    delint(sourceFile);} : (fileName: any) => void
->fileName : any, Symbol(fileName, Decl(APISample_linter.ts, 57, 18))
-
-    // Parse a file
-    let sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true);
->sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 59, 7))
->ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true) : ts.SourceFile
->ts.createSourceFile : (fileName: string, sourceText: string, languageVersion: ts.ScriptTarget, setParentNodes?: boolean) => ts.SourceFile, Symbol(ts.createSourceFile, Decl(typescript.d.ts, 1218, 62))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->createSourceFile : (fileName: string, sourceText: string, languageVersion: ts.ScriptTarget, setParentNodes?: boolean) => ts.SourceFile, Symbol(ts.createSourceFile, Decl(typescript.d.ts, 1218, 62))
->fileName : any, Symbol(fileName, Decl(APISample_linter.ts, 57, 18))
->readFileSync(fileName).toString() : any
->readFileSync(fileName).toString : any
->readFileSync(fileName) : any
->readFileSync : any, Symbol(readFileSync, Decl(APISample_linter.ts, 9, 11))
->fileName : any, Symbol(fileName, Decl(APISample_linter.ts, 57, 18))
->toString : any
->ts.ScriptTarget.ES6 : ts.ScriptTarget, Symbol(ts.ScriptTarget.ES6, Decl(typescript.d.ts, 1118, 16))
->ts.ScriptTarget : typeof ts.ScriptTarget, Symbol(ts.ScriptTarget, Decl(typescript.d.ts, 1115, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
->ScriptTarget : typeof ts.ScriptTarget, Symbol(ts.ScriptTarget, Decl(typescript.d.ts, 1115, 5))
->ES6 : ts.ScriptTarget, Symbol(ts.ScriptTarget.ES6, Decl(typescript.d.ts, 1118, 16))
->true : boolean
-
-    // delint it
-    delint(sourceFile);
->delint(sourceFile) : void
->delint : (sourceFile: ts.SourceFile) => void, Symbol(delint, Decl(APISample_linter.ts, 11, 33))
->sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 59, 7))
-
-});

tests/baselines/reference/APISample_transform.types

@@ -1,44 +0,0 @@
-=== tests/cases/compiler/APISample_transform.ts ===
-
-/*
- * Note: This test is a public API sample. The sample sources can be found 
-         at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#a-simple-transform-function
- *       Please log a "breaking change" issue for any API breaking change affecting this issue
- */
-
-declare var console: any;
->console : any, Symbol(console, Decl(APISample_transform.ts, 7, 11))
-
-import * as ts from "typescript";
->ts : typeof ts, Symbol(ts, Decl(APISample_transform.ts, 9, 6))
-
-const source = "let x: string  = 'string'";
->source : string, Symbol(source, Decl(APISample_transform.ts, 11, 5))
->"let x: string  = 'string'" : string
-
-let result = ts.transpile(source, { module: ts.ModuleKind.CommonJS });
->result : string, Symbol(result, Decl(APISample_transform.ts, 13, 3))
->ts.transpile(source, { module: ts.ModuleKind.CommonJS }) : string
->ts.transpile : (input: string, compilerOptions?: ts.CompilerOptions, fileName?: string, diagnostics?: ts.Diagnostic[]) => string, Symbol(ts.transpile, Decl(typescript.d.ts, 1756, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_transform.ts, 9, 6))
->transpile : (input: string, compilerOptions?: ts.CompilerOptions, fileName?: string, diagnostics?: ts.Diagnostic[]) => string, Symbol(ts.transpile, Decl(typescript.d.ts, 1756, 5))
->source : string, Symbol(source, Decl(APISample_transform.ts, 11, 5))
->{ module: ts.ModuleKind.CommonJS } : { [x: string]: ts.ModuleKind; module: ts.ModuleKind; }
->module : ts.ModuleKind, Symbol(module, Decl(APISample_transform.ts, 13, 35))
->ts.ModuleKind.CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
->ts.ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_transform.ts, 9, 6))
->ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
->CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
-
-console.log(JSON.stringify(result));
->console.log(JSON.stringify(result)) : any
->console.log : any
->console : any, Symbol(console, Decl(APISample_transform.ts, 7, 11))
->log : any
->JSON.stringify(result) : string
->JSON.stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }, Symbol(JSON.stringify, Decl(lib.d.ts, 964, 70), Decl(lib.d.ts, 969, 34), Decl(lib.d.ts, 975, 78), Decl(lib.d.ts, 981, 51), Decl(lib.d.ts, 988, 90))
->JSON : JSON, Symbol(JSON, Decl(lib.d.ts, 955, 42), Decl(lib.d.ts, 1000, 11))
->stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }, Symbol(JSON.stringify, Decl(lib.d.ts, 964, 70), Decl(lib.d.ts, 969, 34), Decl(lib.d.ts, 975, 78), Decl(lib.d.ts, 981, 51), Decl(lib.d.ts, 988, 90))
->result : string, Symbol(result, Decl(APISample_transform.ts, 13, 3))
-

tests/baselines/reference/APISample_watcher.types

@@ -1,443 +0,0 @@
-=== tests/cases/compiler/APISample_watcher.ts ===
-
-/*
- * Note: This test is a public API sample. The sample sources can be found 
-         at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#incremental-build-support-using-the-language-services
- *       Please log a "breaking change" issue for any API breaking change affecting this issue
- */
-
-declare var process: any;
->process : any, Symbol(process, Decl(APISample_watcher.ts, 7, 11))
-
-declare var console: any;
->console : any, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
-
-declare var fs: any;
->fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
-
-declare var path: any;
->path : any, Symbol(path, Decl(APISample_watcher.ts, 10, 11))
-
-import * as ts from "typescript";
->ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
-
-function watch(rootFileNames: string[], options: ts.CompilerOptions) {
->watch : (rootFileNames: string[], options: ts.CompilerOptions) => void, Symbol(watch, Decl(APISample_watcher.ts, 12, 33))
->rootFileNames : string[], Symbol(rootFileNames, Decl(APISample_watcher.ts, 14, 15))
->options : ts.CompilerOptions, Symbol(options, Decl(APISample_watcher.ts, 14, 39))
->ts : any, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
->CompilerOptions : ts.CompilerOptions, Symbol(ts.CompilerOptions, Decl(typescript.d.ts, 1074, 5))
-
-    const files: ts.Map<{ version: number }> = {};
->files : ts.Map<{ version: number; }>, Symbol(files, Decl(APISample_watcher.ts, 15, 9))
->ts : any, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
->Map : ts.Map<T>, Symbol(ts.Map, Decl(typescript.d.ts, 15, 29))
->version : number, Symbol(version, Decl(APISample_watcher.ts, 15, 25))
->{} : { [x: string]: undefined; }
-
-    // initialize the list of files
-    rootFileNames.forEach(fileName => {
->rootFileNames.forEach(fileName => {        files[fileName] = { version: 0 };    }) : void
->rootFileNames.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->rootFileNames : string[], Symbol(rootFileNames, Decl(APISample_watcher.ts, 14, 15))
->forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->fileName => {        files[fileName] = { version: 0 };    } : (fileName: string) => void
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 18, 26))
-
-        files[fileName] = { version: 0 };
->files[fileName] = { version: 0 } : { version: number; }
->files[fileName] : { version: number; }
->files : ts.Map<{ version: number; }>, Symbol(files, Decl(APISample_watcher.ts, 15, 9))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 18, 26))
->{ version: 0 } : { version: number; }
->version : number, Symbol(version, Decl(APISample_watcher.ts, 19, 27))
->0 : number
-
-    });
-
-    // Create the language service host to allow the LS to communicate with the host
-    const servicesHost: ts.LanguageServiceHost = {
->servicesHost : ts.LanguageServiceHost, Symbol(servicesHost, Decl(APISample_watcher.ts, 23, 9))
->ts : any, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
->LanguageServiceHost : ts.LanguageServiceHost, Symbol(ts.LanguageServiceHost, Decl(typescript.d.ts, 1322, 5))
->{        getScriptFileNames: () => rootFileNames,        getScriptVersion: (fileName) => files[fileName] && files[fileName].version.toString(),        getScriptSnapshot: (fileName) => {            if (!fs.existsSync(fileName)) {                return undefined;            }            return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString());        },        getCurrentDirectory: () => process.cwd(),        getCompilationSettings: () => options,        getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),    } : { getScriptFileNames: () => string[]; getScriptVersion: (fileName: string) => string; getScriptSnapshot: (fileName: string) => ts.IScriptSnapshot; getCurrentDirectory: () => any; getCompilationSettings: () => ts.CompilerOptions; getDefaultLibFileName: (options: ts.CompilerOptions) => string; }
-
-        getScriptFileNames: () => rootFileNames,
->getScriptFileNames : () => string[], Symbol(getScriptFileNames, Decl(APISample_watcher.ts, 23, 50))
->() => rootFileNames : () => string[]
->rootFileNames : string[], Symbol(rootFileNames, Decl(APISample_watcher.ts, 14, 15))
-
-        getScriptVersion: (fileName) => files[fileName] && files[fileName].version.toString(),
->getScriptVersion : (fileName: string) => string, Symbol(getScriptVersion, Decl(APISample_watcher.ts, 24, 48))
->(fileName) => files[fileName] && files[fileName].version.toString() : (fileName: string) => string
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 25, 27))
->files[fileName] && files[fileName].version.toString() : string
->files[fileName] : { version: number; }
->files : ts.Map<{ version: number; }>, Symbol(files, Decl(APISample_watcher.ts, 15, 9))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 25, 27))
->files[fileName].version.toString() : string
->files[fileName].version.toString : (radix?: number) => string, Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
->files[fileName].version : number, Symbol(version, Decl(APISample_watcher.ts, 15, 25))
->files[fileName] : { version: number; }
->files : ts.Map<{ version: number; }>, Symbol(files, Decl(APISample_watcher.ts, 15, 9))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 25, 27))
->version : number, Symbol(version, Decl(APISample_watcher.ts, 15, 25))
->toString : (radix?: number) => string, Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
-
-        getScriptSnapshot: (fileName) => {
->getScriptSnapshot : (fileName: string) => ts.IScriptSnapshot, Symbol(getScriptSnapshot, Decl(APISample_watcher.ts, 25, 94))
->(fileName) => {            if (!fs.existsSync(fileName)) {                return undefined;            }            return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString());        } : (fileName: string) => ts.IScriptSnapshot
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 26, 28))
-
-            if (!fs.existsSync(fileName)) {
->!fs.existsSync(fileName) : boolean
->fs.existsSync(fileName) : any
->fs.existsSync : any
->fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
->existsSync : any
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 26, 28))
-
-                return undefined;
->undefined : undefined, Symbol(undefined)
-            }
-
-            return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString());
->ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString()) : ts.IScriptSnapshot
->ts.ScriptSnapshot.fromString : (text: string) => ts.IScriptSnapshot, Symbol(ts.ScriptSnapshot.fromString, Decl(typescript.d.ts, 1315, 27))
->ts.ScriptSnapshot : typeof ts.ScriptSnapshot, Symbol(ts.ScriptSnapshot, Decl(typescript.d.ts, 1314, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
->ScriptSnapshot : typeof ts.ScriptSnapshot, Symbol(ts.ScriptSnapshot, Decl(typescript.d.ts, 1314, 5))
->fromString : (text: string) => ts.IScriptSnapshot, Symbol(ts.ScriptSnapshot.fromString, Decl(typescript.d.ts, 1315, 27))
->fs.readFileSync(fileName).toString() : any
->fs.readFileSync(fileName).toString : any
->fs.readFileSync(fileName) : any
->fs.readFileSync : any
->fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
->readFileSync : any
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 26, 28))
->toString : any
-
-        },
-        getCurrentDirectory: () => process.cwd(),
->getCurrentDirectory : () => any, Symbol(getCurrentDirectory, Decl(APISample_watcher.ts, 32, 10))
->() => process.cwd() : () => any
->process.cwd() : any
->process.cwd : any
->process : any, Symbol(process, Decl(APISample_watcher.ts, 7, 11))
->cwd : any
-
-        getCompilationSettings: () => options,
->getCompilationSettings : () => ts.CompilerOptions, Symbol(getCompilationSettings, Decl(APISample_watcher.ts, 33, 49))
->() => options : () => ts.CompilerOptions
->options : ts.CompilerOptions, Symbol(options, Decl(APISample_watcher.ts, 14, 39))
-
-        getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
->getDefaultLibFileName : (options: ts.CompilerOptions) => string, Symbol(getDefaultLibFileName, Decl(APISample_watcher.ts, 34, 46))
->(options) => ts.getDefaultLibFilePath(options) : (options: ts.CompilerOptions) => string
->options : ts.CompilerOptions, Symbol(options, Decl(APISample_watcher.ts, 35, 32))
->ts.getDefaultLibFilePath(options) : string
->ts.getDefaultLibFilePath : (options: ts.CompilerOptions) => string, Symbol(ts.getDefaultLibFilePath, Decl(typescript.d.ts, 1764, 44))
->ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
->getDefaultLibFilePath : (options: ts.CompilerOptions) => string, Symbol(ts.getDefaultLibFilePath, Decl(typescript.d.ts, 1764, 44))
->options : ts.CompilerOptions, Symbol(options, Decl(APISample_watcher.ts, 35, 32))
-
-    };
-
-    // Create the language service files
-    const services = ts.createLanguageService(servicesHost, ts.createDocumentRegistry())
->services : ts.LanguageService, Symbol(services, Decl(APISample_watcher.ts, 39, 9))
->ts.createLanguageService(servicesHost, ts.createDocumentRegistry()) : ts.LanguageService
->ts.createLanguageService : (host: ts.LanguageServiceHost, documentRegistry?: ts.DocumentRegistry) => ts.LanguageService, Symbol(ts.createLanguageService, Decl(typescript.d.ts, 1762, 97))
->ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
->createLanguageService : (host: ts.LanguageServiceHost, documentRegistry?: ts.DocumentRegistry) => ts.LanguageService, Symbol(ts.createLanguageService, Decl(typescript.d.ts, 1762, 97))
->servicesHost : ts.LanguageServiceHost, Symbol(servicesHost, Decl(APISample_watcher.ts, 23, 9))
->ts.createDocumentRegistry() : ts.DocumentRegistry
->ts.createDocumentRegistry : () => ts.DocumentRegistry, Symbol(ts.createDocumentRegistry, Decl(typescript.d.ts, 1760, 193))
->ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
->createDocumentRegistry : () => ts.DocumentRegistry, Symbol(ts.createDocumentRegistry, Decl(typescript.d.ts, 1760, 193))
-
-    // Now let's watch the files
-    rootFileNames.forEach(fileName => {
->rootFileNames.forEach(fileName => {        // First time around, emit all files        emitFile(fileName);        // Add a watch on the file to handle next change        fs.watchFile(fileName,            { persistent: true, interval: 250 },            (curr, prev) => {                // Check timestamp                if (+curr.mtime <= +prev.mtime) {                    return;                }                // Update the version to signal a change in the file                files[fileName].version++;                // write the changes to disk                emitFile(fileName);            });    }) : void
->rootFileNames.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->rootFileNames : string[], Symbol(rootFileNames, Decl(APISample_watcher.ts, 14, 15))
->forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->fileName => {        // First time around, emit all files        emitFile(fileName);        // Add a watch on the file to handle next change        fs.watchFile(fileName,            { persistent: true, interval: 250 },            (curr, prev) => {                // Check timestamp                if (+curr.mtime <= +prev.mtime) {                    return;                }                // Update the version to signal a change in the file                files[fileName].version++;                // write the changes to disk                emitFile(fileName);            });    } : (fileName: string) => void
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
-
-        // First time around, emit all files
-        emitFile(fileName);
->emitFile(fileName) : void
->emitFile : (fileName: string) => void, Symbol(emitFile, Decl(APISample_watcher.ts, 61, 7))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
-
-        // Add a watch on the file to handle next change
-        fs.watchFile(fileName,
->fs.watchFile(fileName,            { persistent: true, interval: 250 },            (curr, prev) => {                // Check timestamp                if (+curr.mtime <= +prev.mtime) {                    return;                }                // Update the version to signal a change in the file                files[fileName].version++;                // write the changes to disk                emitFile(fileName);            }) : any
->fs.watchFile : any
->fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
->watchFile : any
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
-
-            { persistent: true, interval: 250 },
->{ persistent: true, interval: 250 } : { persistent: boolean; interval: number; }
->persistent : boolean, Symbol(persistent, Decl(APISample_watcher.ts, 48, 13))
->true : boolean
->interval : number, Symbol(interval, Decl(APISample_watcher.ts, 48, 31))
->250 : number
-
-            (curr, prev) => {
->(curr, prev) => {                // Check timestamp                if (+curr.mtime <= +prev.mtime) {                    return;                }                // Update the version to signal a change in the file                files[fileName].version++;                // write the changes to disk                emitFile(fileName);            } : (curr: any, prev: any) => void
->curr : any, Symbol(curr, Decl(APISample_watcher.ts, 49, 13))
->prev : any, Symbol(prev, Decl(APISample_watcher.ts, 49, 18))
-
-                // Check timestamp
-                if (+curr.mtime <= +prev.mtime) {
->+curr.mtime <= +prev.mtime : boolean
->+curr.mtime : number
->curr.mtime : any
->curr : any, Symbol(curr, Decl(APISample_watcher.ts, 49, 13))
->mtime : any
->+prev.mtime : number
->prev.mtime : any
->prev : any, Symbol(prev, Decl(APISample_watcher.ts, 49, 18))
->mtime : any
-
-                    return;
-                }
-
-                // Update the version to signal a change in the file
-                files[fileName].version++;
->files[fileName].version++ : number
->files[fileName].version : number, Symbol(version, Decl(APISample_watcher.ts, 15, 25))
->files[fileName] : { version: number; }
->files : ts.Map<{ version: number; }>, Symbol(files, Decl(APISample_watcher.ts, 15, 9))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
->version : number, Symbol(version, Decl(APISample_watcher.ts, 15, 25))
-
-                // write the changes to disk
-                emitFile(fileName);
->emitFile(fileName) : void
->emitFile : (fileName: string) => void, Symbol(emitFile, Decl(APISample_watcher.ts, 61, 7))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
-
-            });
-    });
-
-    function emitFile(fileName: string) {
->emitFile : (fileName: string) => void, Symbol(emitFile, Decl(APISample_watcher.ts, 61, 7))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
-
-        let output = services.getEmitOutput(fileName);
->output : ts.EmitOutput, Symbol(output, Decl(APISample_watcher.ts, 64, 11))
->services.getEmitOutput(fileName) : ts.EmitOutput
->services.getEmitOutput : (fileName: string) => ts.EmitOutput, Symbol(ts.LanguageService.getEmitOutput, Decl(typescript.d.ts, 1366, 132))
->services : ts.LanguageService, Symbol(services, Decl(APISample_watcher.ts, 39, 9))
->getEmitOutput : (fileName: string) => ts.EmitOutput, Symbol(ts.LanguageService.getEmitOutput, Decl(typescript.d.ts, 1366, 132))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
-
-        if (!output.emitSkipped) {
->!output.emitSkipped : boolean
->output.emitSkipped : boolean, Symbol(ts.EmitOutput.emitSkipped, Decl(typescript.d.ts, 1569, 34))
->output : ts.EmitOutput, Symbol(output, Decl(APISample_watcher.ts, 64, 11))
->emitSkipped : boolean, Symbol(ts.EmitOutput.emitSkipped, Decl(typescript.d.ts, 1569, 34))
-
-            console.log(`Emitting ${fileName}`);
->console.log(`Emitting ${fileName}`) : any
->console.log : any
->console : any, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
->log : any
->`Emitting ${fileName}` : string
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
-        }
-        else {
-            console.log(`Emitting ${fileName} failed`);
->console.log(`Emitting ${fileName} failed`) : any
->console.log : any
->console : any, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
->log : any
->`Emitting ${fileName} failed` : string
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
-
-            logErrors(fileName);
->logErrors(fileName) : void
->logErrors : (fileName: string) => void, Symbol(logErrors, Decl(APISample_watcher.ts, 77, 5))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
-        }
-
-        output.outputFiles.forEach(o => {
->output.outputFiles.forEach(o => {            fs.writeFileSync(o.name, o.text, "utf8");        }) : void
->output.outputFiles.forEach : (callbackfn: (value: ts.OutputFile, index: number, array: ts.OutputFile[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->output.outputFiles : ts.OutputFile[], Symbol(ts.EmitOutput.outputFiles, Decl(typescript.d.ts, 1568, 26))
->output : ts.EmitOutput, Symbol(output, Decl(APISample_watcher.ts, 64, 11))
->outputFiles : ts.OutputFile[], Symbol(ts.EmitOutput.outputFiles, Decl(typescript.d.ts, 1568, 26))
->forEach : (callbackfn: (value: ts.OutputFile, index: number, array: ts.OutputFile[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->o => {            fs.writeFileSync(o.name, o.text, "utf8");        } : (o: ts.OutputFile) => void
->o : ts.OutputFile, Symbol(o, Decl(APISample_watcher.ts, 74, 35))
-
-            fs.writeFileSync(o.name, o.text, "utf8");
->fs.writeFileSync(o.name, o.text, "utf8") : any
->fs.writeFileSync : any
->fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
->writeFileSync : any
->o.name : string, Symbol(ts.OutputFile.name, Decl(typescript.d.ts, 1577, 26))
->o : ts.OutputFile, Symbol(o, Decl(APISample_watcher.ts, 74, 35))
->name : string, Symbol(ts.OutputFile.name, Decl(typescript.d.ts, 1577, 26))
->o.text : string, Symbol(ts.OutputFile.text, Decl(typescript.d.ts, 1579, 36))
->o : ts.OutputFile, Symbol(o, Decl(APISample_watcher.ts, 74, 35))
->text : string, Symbol(ts.OutputFile.text, Decl(typescript.d.ts, 1579, 36))
->"utf8" : string
-
-        });
-    }
-
-    function logErrors(fileName: string) {
->logErrors : (fileName: string) => void, Symbol(logErrors, Decl(APISample_watcher.ts, 77, 5))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 79, 23))
-
-        let allDiagnostics = services.getCompilerOptionsDiagnostics()
->allDiagnostics : ts.Diagnostic[], Symbol(allDiagnostics, Decl(APISample_watcher.ts, 80, 11))
->services.getCompilerOptionsDiagnostics()            .concat(services.getSyntacticDiagnostics(fileName))            .concat(services.getSemanticDiagnostics(fileName)) : ts.Diagnostic[]
->services.getCompilerOptionsDiagnostics()            .concat(services.getSyntacticDiagnostics(fileName))            .concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
->services.getCompilerOptionsDiagnostics()            .concat(services.getSyntacticDiagnostics(fileName)) : ts.Diagnostic[]
->services.getCompilerOptionsDiagnostics()            .concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
->services.getCompilerOptionsDiagnostics() : ts.Diagnostic[]
->services.getCompilerOptionsDiagnostics : () => ts.Diagnostic[], Symbol(ts.LanguageService.getCompilerOptionsDiagnostics, Decl(typescript.d.ts, 1340, 63))
->services : ts.LanguageService, Symbol(services, Decl(APISample_watcher.ts, 39, 9))
->getCompilerOptionsDiagnostics : () => ts.Diagnostic[], Symbol(ts.LanguageService.getCompilerOptionsDiagnostics, Decl(typescript.d.ts, 1340, 63))
-
-            .concat(services.getSyntacticDiagnostics(fileName))
->concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
->services.getSyntacticDiagnostics(fileName) : ts.Diagnostic[]
->services.getSyntacticDiagnostics : (fileName: string) => ts.Diagnostic[], Symbol(ts.LanguageService.getSyntacticDiagnostics, Decl(typescript.d.ts, 1338, 37))
->services : ts.LanguageService, Symbol(services, Decl(APISample_watcher.ts, 39, 9))
->getSyntacticDiagnostics : (fileName: string) => ts.Diagnostic[], Symbol(ts.LanguageService.getSyntacticDiagnostics, Decl(typescript.d.ts, 1338, 37))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 79, 23))
-
-            .concat(services.getSemanticDiagnostics(fileName));
->concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
->services.getSemanticDiagnostics(fileName) : ts.Diagnostic[]
->services.getSemanticDiagnostics : (fileName: string) => ts.Diagnostic[], Symbol(ts.LanguageService.getSemanticDiagnostics, Decl(typescript.d.ts, 1339, 64))
->services : ts.LanguageService, Symbol(services, Decl(APISample_watcher.ts, 39, 9))
->getSemanticDiagnostics : (fileName: string) => ts.Diagnostic[], Symbol(ts.LanguageService.getSemanticDiagnostics, Decl(typescript.d.ts, 1339, 64))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 79, 23))
-
-        allDiagnostics.forEach(diagnostic => {
->allDiagnostics.forEach(diagnostic => {            let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");            if (diagnostic.file) {                let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);                console.log(`  Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);            }            else {                console.log(`  Error: ${message}`);            }        }) : void
->allDiagnostics.forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->allDiagnostics : ts.Diagnostic[], Symbol(allDiagnostics, Decl(APISample_watcher.ts, 80, 11))
->forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->diagnostic => {            let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");            if (diagnostic.file) {                let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);                console.log(`  Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);            }            else {                console.log(`  Error: ${message}`);            }        } : (diagnostic: ts.Diagnostic) => void
->diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
-
-            let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
->message : string, Symbol(message, Decl(APISample_watcher.ts, 85, 15))
->ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n") : string
->ts.flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string, Symbol(ts.flattenDiagnosticMessageText, Decl(typescript.d.ts, 1228, 67))
->ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
->flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string, Symbol(ts.flattenDiagnosticMessageText, Decl(typescript.d.ts, 1228, 67))
->diagnostic.messageText : string | ts.DiagnosticMessageChain, Symbol(ts.Diagnostic.messageText, Decl(typescript.d.ts, 1065, 23))
->diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
->messageText : string | ts.DiagnosticMessageChain, Symbol(ts.Diagnostic.messageText, Decl(typescript.d.ts, 1065, 23))
->"\n" : string
-
-            if (diagnostic.file) {
->diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
->diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
->file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
-
-                let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
->line : number, Symbol(line, Decl(APISample_watcher.ts, 87, 21))
->character : number, Symbol(character, Decl(APISample_watcher.ts, 87, 27))
->diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start) : ts.LineAndCharacter
->diagnostic.file.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1290, 26))
->diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
->diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
->file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
->getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1290, 26))
->diagnostic.start : number, Symbol(ts.Diagnostic.start, Decl(typescript.d.ts, 1063, 25))
->diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
->start : number, Symbol(ts.Diagnostic.start, Decl(typescript.d.ts, 1063, 25))
-
-                console.log(`  Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
->console.log(`  Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`) : any
->console.log : any
->console : any, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
->log : any
->`  Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}` : string
->diagnostic.file.fileName : string, Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
->diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
->diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
->file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
->fileName : string, Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
->line + 1 : number
->line : number, Symbol(line, Decl(APISample_watcher.ts, 87, 21))
->1 : number
->character + 1 : number
->character : number, Symbol(character, Decl(APISample_watcher.ts, 87, 27))
->1 : number
->message : string, Symbol(message, Decl(APISample_watcher.ts, 85, 15))
-            }
-            else {
-                console.log(`  Error: ${message}`);
->console.log(`  Error: ${message}`) : any
->console.log : any
->console : any, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
->log : any
->`  Error: ${message}` : string
->message : string, Symbol(message, Decl(APISample_watcher.ts, 85, 15))
-            }
-        });
-    }
-}
-
-// Initialize files constituting the program as all .ts files in the current directory
-const currentDirectoryFiles = fs.readdirSync(process.cwd()).
->currentDirectoryFiles : any, Symbol(currentDirectoryFiles, Decl(APISample_watcher.ts, 98, 5))
->fs.readdirSync(process.cwd()).    filter(fileName=> fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts") : any
->fs.readdirSync(process.cwd()).    filter : any
->fs.readdirSync(process.cwd()) : any
->fs.readdirSync : any
->fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
->readdirSync : any
->process.cwd() : any
->process.cwd : any
->process : any, Symbol(process, Decl(APISample_watcher.ts, 7, 11))
->cwd : any
-
-    filter(fileName=> fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts");
->filter : any
->fileName=> fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts" : (fileName: any) => boolean
->fileName : any, Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
->fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts" : boolean
->fileName.length >= 3 : boolean
->fileName.length : any
->fileName : any, Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
->length : any
->3 : number
->fileName.substr(fileName.length - 3, 3) === ".ts" : boolean
->fileName.substr(fileName.length - 3, 3) : any
->fileName.substr : any
->fileName : any, Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
->substr : any
->fileName.length - 3 : number
->fileName.length : any
->fileName : any, Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
->length : any
->3 : number
->3 : number
->".ts" : string
-
-// Start the watcher
-watch(currentDirectoryFiles, { module: ts.ModuleKind.CommonJS });
->watch(currentDirectoryFiles, { module: ts.ModuleKind.CommonJS }) : void
->watch : (rootFileNames: string[], options: ts.CompilerOptions) => void, Symbol(watch, Decl(APISample_watcher.ts, 12, 33))
->currentDirectoryFiles : any, Symbol(currentDirectoryFiles, Decl(APISample_watcher.ts, 98, 5))
->{ module: ts.ModuleKind.CommonJS } : { [x: string]: ts.ModuleKind; module: ts.ModuleKind; }
->module : ts.ModuleKind, Symbol(module, Decl(APISample_watcher.ts, 102, 30))
->ts.ModuleKind.CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
->ts.ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
->ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
->CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
-

tests/baselines/reference/AmbientModuleAndAmbientFunctionWithTheSameNameAndCommonRoot.symbols

@@ -0,0 +1,32 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
+declare module Point {
+>Point : Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.d.ts, 0, 0))
+
+    export var Origin: { x: number; y: number; }
+>Origin : Symbol(Origin, Decl(module.d.ts, 1, 14))
+>x : Symbol(x, Decl(module.d.ts, 1, 24))
+>y : Symbol(y, Decl(module.d.ts, 1, 35))
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/function.d.ts ===
+declare function Point(): { x: number; y: number; }
+>Point : Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.d.ts, 0, 0))
+>x : Symbol(x, Decl(function.d.ts, 0, 27))
+>y : Symbol(y, Decl(function.d.ts, 0, 38))
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
+var cl: { x: number; y: number; }
+>cl : Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>x : Symbol(x, Decl(test.ts, 0, 9))
+>y : Symbol(y, Decl(test.ts, 0, 20))
+
+var cl = Point();
+>cl : Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>Point : Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.d.ts, 0, 0))
+
+var cl = Point.Origin;
+>cl : Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>Point.Origin : Symbol(Point.Origin, Decl(module.d.ts, 1, 14))
+>Point : Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.d.ts, 0, 0))
+>Origin : Symbol(Point.Origin, Decl(module.d.ts, 1, 14))
+

tests/baselines/reference/AmbientModuleAndAmbientFunctionWithTheSameNameAndCommonRoot.types

@@ -1,33 +1,33 @@
 === tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
 declare module Point {
->Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.d.ts, 0, 0))
+>Point : typeof Point
 
     export var Origin: { x: number; y: number; }
->Origin : { x: number; y: number; }, Symbol(Origin, Decl(module.d.ts, 1, 14))
->x : number, Symbol(x, Decl(module.d.ts, 1, 24))
->y : number, Symbol(y, Decl(module.d.ts, 1, 35))
+>Origin : { x: number; y: number; }
+>x : number
+>y : number
 }
 
 === tests/cases/conformance/internalModules/DeclarationMerging/function.d.ts ===
 declare function Point(): { x: number; y: number; }
->Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.d.ts, 0, 0))
->x : number, Symbol(x, Decl(function.d.ts, 0, 27))
->y : number, Symbol(y, Decl(function.d.ts, 0, 38))
+>Point : typeof Point
+>x : number
+>y : number
 
 === tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
 var cl: { x: number; y: number; }
->cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
->x : number, Symbol(x, Decl(test.ts, 0, 9))
->y : number, Symbol(y, Decl(test.ts, 0, 20))
+>cl : { x: number; y: number; }
+>x : number
+>y : number
 
 var cl = Point();
->cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>cl : { x: number; y: number; }
 >Point() : { x: number; y: number; }
->Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.d.ts, 0, 0))
+>Point : typeof Point
 
 var cl = Point.Origin;
->cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
->Point.Origin : { x: number; y: number; }, Symbol(Point.Origin, Decl(module.d.ts, 1, 14))
->Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.d.ts, 0, 0))
->Origin : { x: number; y: number; }, Symbol(Point.Origin, Decl(module.d.ts, 1, 14))
+>cl : { x: number; y: number; }
+>Point.Origin : { x: number; y: number; }
+>Point : typeof Point
+>Origin : { x: number; y: number; }
 

tests/baselines/reference/AmbientModuleAndAmbientWithSameNameAndCommonRoot.symbols

@@ -0,0 +1,58 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
+declare module A {
+>A : Symbol(A, Decl(module.d.ts, 0, 0), Decl(class.d.ts, 0, 0))
+
+    export module Point {
+>Point : Symbol(Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
+
+        export var Origin: {
+>Origin : Symbol(Origin, Decl(module.d.ts, 2, 18))
+
+            x: number;
+>x : Symbol(x, Decl(module.d.ts, 2, 28))
+
+            y: number;
+>y : Symbol(y, Decl(module.d.ts, 3, 22))
+        }
+    }
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/class.d.ts ===
+declare module A {
+>A : Symbol(A, Decl(module.d.ts, 0, 0), Decl(class.d.ts, 0, 0))
+
+    export class Point {
+>Point : Symbol(Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
+
+        constructor(x: number, y: number);
+>x : Symbol(x, Decl(class.d.ts, 2, 20))
+>y : Symbol(y, Decl(class.d.ts, 2, 30))
+
+        x: number;
+>x : Symbol(x, Decl(class.d.ts, 2, 42))
+
+        y: number;
+>y : Symbol(y, Decl(class.d.ts, 3, 18))
+    }
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
+var p: { x: number; y: number; }
+>p : Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>x : Symbol(x, Decl(test.ts, 0, 8))
+>y : Symbol(y, Decl(test.ts, 0, 19))
+
+var p = A.Point.Origin;
+>p : Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>A.Point.Origin : Symbol(A.Point.Origin, Decl(module.d.ts, 2, 18))
+>A.Point : Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
+>A : Symbol(A, Decl(module.d.ts, 0, 0), Decl(class.d.ts, 0, 0))
+>Point : Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
+>Origin : Symbol(A.Point.Origin, Decl(module.d.ts, 2, 18))
+
+var p = new A.Point(0, 0); // unexpected error here, bug 840000
+>p : Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>A.Point : Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
+>A : Symbol(A, Decl(module.d.ts, 0, 0), Decl(class.d.ts, 0, 0))
+>Point : Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
+ 

tests/baselines/reference/AmbientModuleAndAmbientWithSameNameAndCommonRoot.types

@@ -1,61 +1,61 @@
 === tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
 declare module A {
->A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(class.d.ts, 0, 0))
+>A : typeof A
 
     export module Point {
->Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
+>Point : typeof Point
 
         export var Origin: {
->Origin : { x: number; y: number; }, Symbol(Origin, Decl(module.d.ts, 2, 18))
+>Origin : { x: number; y: number; }
 
             x: number;
->x : number, Symbol(x, Decl(module.d.ts, 2, 28))
+>x : number
 
             y: number;
->y : number, Symbol(y, Decl(module.d.ts, 3, 22))
+>y : number
         }
     }
 }
 
 === tests/cases/conformance/internalModules/DeclarationMerging/class.d.ts ===
 declare module A {
->A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(class.d.ts, 0, 0))
+>A : typeof A
 
     export class Point {
->Point : Point, Symbol(Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
+>Point : Point
 
         constructor(x: number, y: number);
->x : number, Symbol(x, Decl(class.d.ts, 2, 20))
->y : number, Symbol(y, Decl(class.d.ts, 2, 30))
+>x : number
+>y : number
 
         x: number;
->x : number, Symbol(x, Decl(class.d.ts, 2, 42))
+>x : number
 
         y: number;
->y : number, Symbol(y, Decl(class.d.ts, 3, 18))
+>y : number
     }
 }
 
 === tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
 var p: { x: number; y: number; }
->p : { x: number; y: number; }, Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
->x : number, Symbol(x, Decl(test.ts, 0, 8))
->y : number, Symbol(y, Decl(test.ts, 0, 19))
+>p : { x: number; y: number; }
+>x : number
+>y : number
 
 var p = A.Point.Origin;
->p : { x: number; y: number; }, Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
->A.Point.Origin : { x: number; y: number; }, Symbol(A.Point.Origin, Decl(module.d.ts, 2, 18))
->A.Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
->A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(class.d.ts, 0, 0))
->Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
->Origin : { x: number; y: number; }, Symbol(A.Point.Origin, Decl(module.d.ts, 2, 18))
+>p : { x: number; y: number; }
+>A.Point.Origin : { x: number; y: number; }
+>A.Point : typeof A.Point
+>A : typeof A
+>Point : typeof A.Point
+>Origin : { x: number; y: number; }
 
 var p = new A.Point(0, 0); // unexpected error here, bug 840000
->p : { x: number; y: number; }, Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>p : { x: number; y: number; }
 >new A.Point(0, 0) : A.Point
->A.Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
->A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(class.d.ts, 0, 0))
->Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
+>A.Point : typeof A.Point
+>A : typeof A
+>Point : typeof A.Point
 >0 : number
 >0 : number
  

tests/baselines/reference/AmbientModuleAndNonAmbientClassWithSameNameAndCommonRoot.symbols

@@ -0,0 +1,52 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
+declare module A {
+>A : Symbol(A, Decl(module.d.ts, 0, 0), Decl(classPoint.ts, 0, 0))
+
+    export module Point {
+>Point : Symbol(Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
+
+        export var Origin: {
+>Origin : Symbol(Origin, Decl(module.d.ts, 2, 18))
+
+            x: number;
+>x : Symbol(x, Decl(module.d.ts, 2, 28))
+
+            y: number;
+>y : Symbol(y, Decl(module.d.ts, 3, 22))
+        }
+    }
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/classPoint.ts ===
+module A {
+>A : Symbol(A, Decl(module.d.ts, 0, 0), Decl(classPoint.ts, 0, 0))
+
+    export class Point {
+>Point : Symbol(Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
+
+        constructor(public x: number, public y: number) { }
+>x : Symbol(x, Decl(classPoint.ts, 2, 20))
+>y : Symbol(y, Decl(classPoint.ts, 2, 37))
+    }
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
+var p: { x: number; y: number; }
+>p : Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>x : Symbol(x, Decl(test.ts, 0, 8))
+>y : Symbol(y, Decl(test.ts, 0, 19))
+
+var p = A.Point.Origin;
+>p : Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>A.Point.Origin : Symbol(A.Point.Origin, Decl(module.d.ts, 2, 18))
+>A.Point : Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
+>A : Symbol(A, Decl(module.d.ts, 0, 0), Decl(classPoint.ts, 0, 0))
+>Point : Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
+>Origin : Symbol(A.Point.Origin, Decl(module.d.ts, 2, 18))
+
+var p = new A.Point(0, 0); // unexpected error here, bug 840000
+>p : Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>A.Point : Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
+>A : Symbol(A, Decl(module.d.ts, 0, 0), Decl(classPoint.ts, 0, 0))
+>Point : Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
+

tests/baselines/reference/AmbientModuleAndNonAmbientClassWithSameNameAndCommonRoot.types

@@ -1,55 +1,55 @@
 === tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
 declare module A {
->A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(classPoint.ts, 0, 0))
+>A : typeof A
 
     export module Point {
->Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
+>Point : typeof Point
 
         export var Origin: {
->Origin : { x: number; y: number; }, Symbol(Origin, Decl(module.d.ts, 2, 18))
+>Origin : { x: number; y: number; }
 
             x: number;
->x : number, Symbol(x, Decl(module.d.ts, 2, 28))
+>x : number
 
             y: number;
->y : number, Symbol(y, Decl(module.d.ts, 3, 22))
+>y : number
         }
     }
 }
 
 === tests/cases/conformance/internalModules/DeclarationMerging/classPoint.ts ===
 module A {
->A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(classPoint.ts, 0, 0))
+>A : typeof A
 
     export class Point {
->Point : Point, Symbol(Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
+>Point : Point
 
         constructor(public x: number, public y: number) { }
->x : number, Symbol(x, Decl(classPoint.ts, 2, 20))
->y : number, Symbol(y, Decl(classPoint.ts, 2, 37))
+>x : number
+>y : number
     }
 }
 
 === tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
 var p: { x: number; y: number; }
->p : { x: number; y: number; }, Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
->x : number, Symbol(x, Decl(test.ts, 0, 8))
->y : number, Symbol(y, Decl(test.ts, 0, 19))
+>p : { x: number; y: number; }
+>x : number
+>y : number
 
 var p = A.Point.Origin;
->p : { x: number; y: number; }, Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
->A.Point.Origin : { x: number; y: number; }, Symbol(A.Point.Origin, Decl(module.d.ts, 2, 18))
->A.Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
->A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(classPoint.ts, 0, 0))
->Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
->Origin : { x: number; y: number; }, Symbol(A.Point.Origin, Decl(module.d.ts, 2, 18))
+>p : { x: number; y: number; }
+>A.Point.Origin : { x: number; y: number; }
+>A.Point : typeof A.Point
+>A : typeof A
+>Point : typeof A.Point
+>Origin : { x: number; y: number; }
 
 var p = new A.Point(0, 0); // unexpected error here, bug 840000
->p : { x: number; y: number; }, Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>p : { x: number; y: number; }
 >new A.Point(0, 0) : A.Point
->A.Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
->A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(classPoint.ts, 0, 0))
->Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
+>A.Point : typeof A.Point
+>A : typeof A
+>Point : typeof A.Point
 >0 : number
 >0 : number
 

tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.symbols

@@ -0,0 +1,35 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
+declare module Point {
+>Point : Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.ts, 0, 0))
+
+    export var Origin: { x: number; y: number; }
+>Origin : Symbol(Origin, Decl(module.d.ts, 1, 14))
+>x : Symbol(x, Decl(module.d.ts, 1, 24))
+>y : Symbol(y, Decl(module.d.ts, 1, 35))
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/function.ts ===
+function Point() {
+>Point : Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.ts, 0, 0))
+
+    return { x: 0, y: 0 };
+>x : Symbol(x, Decl(function.ts, 1, 12))
+>y : Symbol(y, Decl(function.ts, 1, 18))
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
+var cl: { x: number; y: number; }
+>cl : Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>x : Symbol(x, Decl(test.ts, 0, 9))
+>y : Symbol(y, Decl(test.ts, 0, 20))
+
+var cl = Point();
+>cl : Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>Point : Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.ts, 0, 0))
+
+var cl = Point.Origin;
+>cl : Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>Point.Origin : Symbol(Point.Origin, Decl(module.d.ts, 1, 14))
+>Point : Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.ts, 0, 0))
+>Origin : Symbol(Point.Origin, Decl(module.d.ts, 1, 14))
+

tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.types

@@ -1,39 +1,39 @@
 === tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
 declare module Point {
->Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.ts, 0, 0))
+>Point : typeof Point
 
     export var Origin: { x: number; y: number; }
->Origin : { x: number; y: number; }, Symbol(Origin, Decl(module.d.ts, 1, 14))
->x : number, Symbol(x, Decl(module.d.ts, 1, 24))
->y : number, Symbol(y, Decl(module.d.ts, 1, 35))
+>Origin : { x: number; y: number; }
+>x : number
+>y : number
 }
 
 === tests/cases/conformance/internalModules/DeclarationMerging/function.ts ===
 function Point() {
->Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.ts, 0, 0))
+>Point : typeof Point
 
     return { x: 0, y: 0 };
 >{ x: 0, y: 0 } : { x: number; y: number; }
->x : number, Symbol(x, Decl(function.ts, 1, 12))
+>x : number
 >0 : number
->y : number, Symbol(y, Decl(function.ts, 1, 18))
+>y : number
 >0 : number
 }
 
 === tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
 var cl: { x: number; y: number; }
->cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
->x : number, Symbol(x, Decl(test.ts, 0, 9))
->y : number, Symbol(y, Decl(test.ts, 0, 20))
+>cl : { x: number; y: number; }
+>x : number
+>y : number
 
 var cl = Point();
->cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>cl : { x: number; y: number; }
 >Point() : { x: number; y: number; }
->Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.ts, 0, 0))
+>Point : typeof Point
 
 var cl = Point.Origin;
->cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
->Point.Origin : { x: number; y: number; }, Symbol(Point.Origin, Decl(module.d.ts, 1, 14))
->Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.ts, 0, 0))
->Origin : { x: number; y: number; }, Symbol(Point.Origin, Decl(module.d.ts, 1, 14))
+>cl : { x: number; y: number; }
+>Point.Origin : { x: number; y: number; }
+>Point : typeof Point
+>Origin : { x: number; y: number; }
 

tests/baselines/reference/ArrowFunction4.symbols

@@ -0,0 +1,7 @@
+=== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction4.ts ===
+var v = (a, b) => {
+>v : Symbol(v, Decl(ArrowFunction4.ts, 0, 3))
+>a : Symbol(a, Decl(ArrowFunction4.ts, 0, 9))
+>b : Symbol(b, Decl(ArrowFunction4.ts, 0, 11))
+   
+};

tests/baselines/reference/ArrowFunction4.types

@@ -1,8 +1,8 @@
 === tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction4.ts ===
 var v = (a, b) => {
->v : (a: any, b: any) => void, Symbol(v, Decl(ArrowFunction4.ts, 0, 3))
+>v : (a: any, b: any) => void
 >(a, b) => {   } : (a: any, b: any) => void
->a : any, Symbol(a, Decl(ArrowFunction4.ts, 0, 9))
->b : any, Symbol(b, Decl(ArrowFunction4.ts, 0, 11))
+>a : any
+>b : any
    
 };

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.symbols

@@ -0,0 +1,47 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts ===
+class Point {
+>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 4, 1))
+
+    constructor(public x: number, public y: number) { }
+>x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 16))
+>y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 33))
+
+    static Origin(): Point { return { x: 0, y: 0 }; }
+>Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 55))
+>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 4, 1))
+>x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 3, 37))
+>y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 3, 43))
+}
+
+module Point {
+>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 4, 1))
+
+    function Origin() { return ""; }// not an error, since not exported
+>Origin : Symbol(Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 6, 14))
+}
+
+
+module A {
+>A : Symbol(A, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 8, 1))
+
+    export class Point {
+>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 16, 5))
+
+        constructor(public x: number, public y: number) { }
+>x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 20))
+>y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 37))
+
+        static Origin(): Point { return { x: 0, y: 0 }; }
+>Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 59))
+>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 16, 5))
+>x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 15, 41))
+>y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 15, 47))
+    }
+
+    export module Point {
+>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 16, 5))
+
+        function Origin() { return ""; }// not an error since not exported
+>Origin : Symbol(Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 18, 25))
+    }
+}

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.types

@@ -1,55 +1,55 @@
 === tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts ===
 class Point {
->Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 4, 1))
+>Point : Point
 
     constructor(public x: number, public y: number) { }
->x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 16))
->y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 33))
+>x : number
+>y : number
 
     static Origin(): Point { return { x: 0, y: 0 }; }
->Origin : () => Point, Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 55))
->Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 4, 1))
+>Origin : () => Point
+>Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
->x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 3, 37))
+>x : number
 >0 : number
->y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 3, 43))
+>y : number
 >0 : number
 }
 
 module Point {
->Point : typeof Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 4, 1))
+>Point : typeof Point
 
     function Origin() { return ""; }// not an error, since not exported
->Origin : () => string, Symbol(Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 6, 14))
+>Origin : () => string
 >"" : string
 }
 
 
 module A {
->A : typeof A, Symbol(A, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 8, 1))
+>A : typeof A
 
     export class Point {
->Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 16, 5))
+>Point : Point
 
         constructor(public x: number, public y: number) { }
->x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 20))
->y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 37))
+>x : number
+>y : number
 
         static Origin(): Point { return { x: 0, y: 0 }; }
->Origin : () => Point, Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 59))
->Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 16, 5))
+>Origin : () => Point
+>Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
->x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 15, 41))
+>x : number
 >0 : number
->y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 15, 47))
+>y : number
 >0 : number
     }
 
     export module Point {
->Point : typeof Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 16, 5))
+>Point : typeof Point
 
         function Origin() { return ""; }// not an error since not exported
->Origin : () => string, Symbol(Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 18, 25))
+>Origin : () => string
 >"" : string
     }
 }

tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.symbols

@@ -0,0 +1,47 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts ===
+class Point {
+>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 4, 1))
+
+    constructor(public x: number, public y: number) { }
+>x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 16))
+>y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 33))
+
+    static Origin: Point = { x: 0, y: 0 };
+>Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 55))
+>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 4, 1))
+>x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 3, 28))
+>y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 3, 34))
+}
+
+module Point {
+>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 4, 1))
+
+    var Origin = ""; // not an error, since not exported
+>Origin : Symbol(Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 7, 7))
+}
+
+
+module A {
+>A : Symbol(A, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 8, 1))
+
+    export class Point {
+>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 16, 5))
+
+        constructor(public x: number, public y: number) { }
+>x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 20))
+>y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 37))
+
+        static Origin: Point = { x: 0, y: 0 };
+>Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 59))
+>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 16, 5))
+>x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 15, 32))
+>y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 15, 38))
+    }
+
+    export module Point {
+>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 16, 5))
+
+        var Origin = ""; // not an error since not exported
+>Origin : Symbol(Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 19, 11))
+    }
+}

tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.types

@@ -1,55 +1,55 @@
 === tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts ===
 class Point {
->Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 4, 1))
+>Point : Point
 
     constructor(public x: number, public y: number) { }
->x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 16))
->y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 33))
+>x : number
+>y : number
 
     static Origin: Point = { x: 0, y: 0 };
->Origin : Point, Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 55))
->Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 4, 1))
+>Origin : Point
+>Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
->x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 3, 28))
+>x : number
 >0 : number
->y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 3, 34))
+>y : number
 >0 : number
 }
 
 module Point {
->Point : typeof Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 4, 1))
+>Point : typeof Point
 
     var Origin = ""; // not an error, since not exported
->Origin : string, Symbol(Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 7, 7))
+>Origin : string
 >"" : string
 }
 
 
 module A {
->A : typeof A, Symbol(A, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 8, 1))
+>A : typeof A
 
     export class Point {
->Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 16, 5))
+>Point : Point
 
         constructor(public x: number, public y: number) { }
->x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 20))
->y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 37))
+>x : number
+>y : number
 
         static Origin: Point = { x: 0, y: 0 };
->Origin : Point, Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 59))
->Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 16, 5))
+>Origin : Point
+>Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
->x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 15, 32))
+>x : number
 >0 : number
->y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 15, 38))
+>y : number
 >0 : number
     }
 
     export module Point {
->Point : typeof Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 16, 5))
+>Point : typeof Point
 
         var Origin = ""; // not an error since not exported
->Origin : string, Symbol(Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 19, 11))
+>Origin : string
 >"" : string
     }
 }

tests/baselines/reference/ClassAndModuleThatMergeWithStringIndexerAndExportedFunctionWithTypeIncompatibleWithIndexer.symbols

@@ -0,0 +1,3 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStringIndexerAndExportedFunctionWithTypeIncompatibleWithIndexer.ts ===
+ 
+No type information for this code.

tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRootES6.errors.txt

@@ -0,0 +1,44 @@
+tests/cases/conformance/internalModules/DeclarationMerging/module.ts(2,19): error TS2433: A module declaration cannot be in a different file from a class or function with which it is merged
+
+
+==== tests/cases/conformance/internalModules/DeclarationMerging/class.ts (0 errors) ====
+    module X.Y {
+        export class Point {
+            constructor(x: number, y: number) {
+                this.x = x;
+                this.y = y;
+            }
+            x: number;
+            y: number;
+        }
+    }
+    
+==== tests/cases/conformance/internalModules/DeclarationMerging/module.ts (1 errors) ====
+    module X.Y {
+        export module Point {
+                      ~~~~~
+!!! error TS2433: A module declaration cannot be in a different file from a class or function with which it is merged
+            export var Origin = new Point(0, 0);
+        }
+    }
+    
+==== tests/cases/conformance/internalModules/DeclarationMerging/test.ts (0 errors) ====
+    //var cl: { x: number; y: number; }
+    var cl = new X.Y.Point(1,1);
+    var cl = X.Y.Point.Origin; // error not expected here same as bug 83996 ?
+    
+    
+==== tests/cases/conformance/internalModules/DeclarationMerging/simple.ts (0 errors) ====
+    class A {
+        id: string;
+    }
+    
+    module A {
+        export var Instance = new A();
+    }
+    
+    // ensure merging works as expected
+    var a = A.Instance;
+    var a = new A();
+    var a: { id: string };
+    

tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRootES6.js

@@ -0,0 +1,81 @@
+//// [tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleWithSameNameAndCommonRootES6.ts] ////
+
+//// [class.ts]
+module X.Y {
+    export class Point {
+        constructor(x: number, y: number) {
+            this.x = x;
+            this.y = y;
+        }
+        x: number;
+        y: number;
+    }
+}
+
+//// [module.ts]
+module X.Y {
+    export module Point {
+        export var Origin = new Point(0, 0);
+    }
+}
+
+//// [test.ts]
+//var cl: { x: number; y: number; }
+var cl = new X.Y.Point(1,1);
+var cl = X.Y.Point.Origin; // error not expected here same as bug 83996 ?
+
+
+//// [simple.ts]
+class A {
+    id: string;
+}
+
+module A {
+    export var Instance = new A();
+}
+
+// ensure merging works as expected
+var a = A.Instance;
+var a = new A();
+var a: { id: string };
+
+
+//// [class.js]
+var X;
+(function (X) {
+    var Y;
+    (function (Y) {
+        class Point {
+            constructor(x, y) {
+                this.x = x;
+                this.y = y;
+            }
+        }
+        Y.Point = Point;
+    })(Y = X.Y || (X.Y = {}));
+})(X || (X = {}));
+//// [module.js]
+var X;
+(function (X) {
+    var Y;
+    (function (Y) {
+        var Point;
+        (function (Point) {
+            Point.Origin = new Point(0, 0);
+        })(Point = Y.Point || (Y.Point = {}));
+    })(Y = X.Y || (X.Y = {}));
+})(X || (X = {}));
+//// [test.js]
+//var cl: { x: number; y: number; }
+var cl = new X.Y.Point(1, 1);
+var cl = X.Y.Point.Origin; // error not expected here same as bug 83996 ?
+//// [simple.js]
+class A {
+}
+(function (A) {
+    A.Instance = new A();
+})(A || (A = {}));
+// ensure merging works as expected
+var a = A.Instance;
+var a = new A();
+var a;

tests/baselines/reference/ES3For-ofTypeCheck2.symbols

@@ -0,0 +1,4 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES3For-ofTypeCheck2.ts ===
+for (var v of [true]) { }
+>v : Symbol(v, Decl(ES3For-ofTypeCheck2.ts, 0, 8))
+

tests/baselines/reference/ES3For-ofTypeCheck2.types

@@ -1,6 +1,6 @@
 === tests/cases/conformance/statements/for-ofStatements/ES3For-ofTypeCheck2.ts ===
 for (var v of [true]) { }
->v : boolean, Symbol(v, Decl(ES3For-ofTypeCheck2.ts, 0, 8))
+>v : boolean
 >[true] : boolean[]
 >true : boolean
 

tests/baselines/reference/ES3For-ofTypeCheck6.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES3For-ofTypeCheck6.ts ===
+var union: string[] | number[];
+>union : Symbol(union, Decl(ES3For-ofTypeCheck6.ts, 0, 3))
+
+for (var v of union) { }
+>v : Symbol(v, Decl(ES3For-ofTypeCheck6.ts, 1, 8))
+>union : Symbol(union, Decl(ES3For-ofTypeCheck6.ts, 0, 3))
+

tests/baselines/reference/ES3For-ofTypeCheck6.types

@@ -1,8 +1,8 @@
 === tests/cases/conformance/statements/for-ofStatements/ES3For-ofTypeCheck6.ts ===
 var union: string[] | number[];
->union : string[] | number[], Symbol(union, Decl(ES3For-ofTypeCheck6.ts, 0, 3))
+>union : string[] | number[]
 
 for (var v of union) { }
->v : string | number, Symbol(v, Decl(ES3For-ofTypeCheck6.ts, 1, 8))
->union : string[] | number[], Symbol(union, Decl(ES3For-ofTypeCheck6.ts, 0, 3))
+>v : string | number
+>union : string[] | number[]
 

tests/baselines/reference/ES5For-of10.symbols

@@ -0,0 +1,23 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of10.ts ===
+function foo() {
+>foo : Symbol(foo, Decl(ES5For-of10.ts, 0, 0))
+
+    return { x: 0 };
+>x : Symbol(x, Decl(ES5For-of10.ts, 1, 12))
+}
+for (foo().x of []) {
+>foo().x : Symbol(x, Decl(ES5For-of10.ts, 1, 12))
+>foo : Symbol(foo, Decl(ES5For-of10.ts, 0, 0))
+>x : Symbol(x, Decl(ES5For-of10.ts, 1, 12))
+
+    for (foo().x of [])
+>foo().x : Symbol(x, Decl(ES5For-of10.ts, 1, 12))
+>foo : Symbol(foo, Decl(ES5For-of10.ts, 0, 0))
+>x : Symbol(x, Decl(ES5For-of10.ts, 1, 12))
+
+        var p = foo().x;
+>p : Symbol(p, Decl(ES5For-of10.ts, 5, 11))
+>foo().x : Symbol(x, Decl(ES5For-of10.ts, 1, 12))
+>foo : Symbol(foo, Decl(ES5For-of10.ts, 0, 0))
+>x : Symbol(x, Decl(ES5For-of10.ts, 1, 12))
+}

tests/baselines/reference/ES5For-of10.types

@@ -1,30 +1,30 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of10.ts ===
 function foo() {
->foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of10.ts, 0, 0))
+>foo : () => { x: number; }
 
     return { x: 0 };
 >{ x: 0 } : { x: number; }
->x : number, Symbol(x, Decl(ES5For-of10.ts, 1, 12))
+>x : number
 >0 : number
 }
 for (foo().x of []) {
->foo().x : number, Symbol(x, Decl(ES5For-of10.ts, 1, 12))
+>foo().x : number
 >foo() : { x: number; }
->foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of10.ts, 0, 0))
->x : number, Symbol(x, Decl(ES5For-of10.ts, 1, 12))
+>foo : () => { x: number; }
+>x : number
 >[] : undefined[]
 
     for (foo().x of [])
->foo().x : number, Symbol(x, Decl(ES5For-of10.ts, 1, 12))
+>foo().x : number
 >foo() : { x: number; }
->foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of10.ts, 0, 0))
->x : number, Symbol(x, Decl(ES5For-of10.ts, 1, 12))
+>foo : () => { x: number; }
+>x : number
 >[] : undefined[]
 
         var p = foo().x;
->p : number, Symbol(p, Decl(ES5For-of10.ts, 5, 11))
->foo().x : number, Symbol(x, Decl(ES5For-of10.ts, 1, 12))
+>p : number
+>foo().x : number
 >foo() : { x: number; }
->foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of10.ts, 0, 0))
->x : number, Symbol(x, Decl(ES5For-of10.ts, 1, 12))
+>foo : () => { x: number; }
+>x : number
 }

tests/baselines/reference/ES5For-of11.symbols

@@ -0,0 +1,7 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of11.ts ===
+var v;
+>v : Symbol(v, Decl(ES5For-of11.ts, 0, 3))
+
+for (v of []) { }
+>v : Symbol(v, Decl(ES5For-of11.ts, 0, 3))
+

tests/baselines/reference/ES5For-of11.types

@@ -1,8 +1,8 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of11.ts ===
 var v;
->v : any, Symbol(v, Decl(ES5For-of11.ts, 0, 3))
+>v : any
 
 for (v of []) { }
->v : any, Symbol(v, Decl(ES5For-of11.ts, 0, 3))
+>v : any
 >[] : undefined[]
 

tests/baselines/reference/ES5For-of13.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of13.ts ===
+for (let v of ['a', 'b', 'c']) {
+>v : Symbol(v, Decl(ES5For-of13.ts, 0, 8))
+
+    var x = v;
+>x : Symbol(x, Decl(ES5For-of13.ts, 1, 7))
+>v : Symbol(v, Decl(ES5For-of13.ts, 0, 8))
+}

tests/baselines/reference/ES5For-of13.types

@@ -1,12 +1,12 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of13.ts ===
 for (let v of ['a', 'b', 'c']) {
->v : string, Symbol(v, Decl(ES5For-of13.ts, 0, 8))
+>v : string
 >['a', 'b', 'c'] : string[]
 >'a' : string
 >'b' : string
 >'c' : string
 
     var x = v;
->x : string, Symbol(x, Decl(ES5For-of13.ts, 1, 7))
->v : string, Symbol(v, Decl(ES5For-of13.ts, 0, 8))
+>x : string
+>v : string
 }

tests/baselines/reference/ES5For-of14.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of14.ts ===
+for (const v of []) {
+>v : Symbol(v, Decl(ES5For-of14.ts, 0, 10))
+
+    var x = v;
+>x : Symbol(x, Decl(ES5For-of14.ts, 1, 7))
+>v : Symbol(v, Decl(ES5For-of14.ts, 0, 10))
+}

tests/baselines/reference/ES5For-of14.types

@@ -1,9 +1,9 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of14.ts ===
 for (const v of []) {
->v : any, Symbol(v, Decl(ES5For-of14.ts, 0, 10))
+>v : any
 >[] : undefined[]
 
     var x = v;
->x : any, Symbol(x, Decl(ES5For-of14.ts, 1, 7))
->v : any, Symbol(v, Decl(ES5For-of14.ts, 0, 10))
+>x : any
+>v : any
 }

tests/baselines/reference/ES5For-of15.symbols

@@ -0,0 +1,15 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of15.ts ===
+for (let v of []) {
+>v : Symbol(v, Decl(ES5For-of15.ts, 0, 8))
+
+    v;
+>v : Symbol(v, Decl(ES5For-of15.ts, 0, 8))
+
+    for (const v of []) {
+>v : Symbol(v, Decl(ES5For-of15.ts, 2, 14))
+
+        var x = v;
+>x : Symbol(x, Decl(ES5For-of15.ts, 3, 11))
+>v : Symbol(v, Decl(ES5For-of15.ts, 2, 14))
+    }
+}

tests/baselines/reference/ES5For-of15.types

@@ -1,17 +1,17 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of15.ts ===
 for (let v of []) {
->v : any, Symbol(v, Decl(ES5For-of15.ts, 0, 8))
+>v : any
 >[] : undefined[]
 
     v;
->v : any, Symbol(v, Decl(ES5For-of15.ts, 0, 8))
+>v : any
 
     for (const v of []) {
->v : any, Symbol(v, Decl(ES5For-of15.ts, 2, 14))
+>v : any
 >[] : undefined[]
 
         var x = v;
->x : any, Symbol(x, Decl(ES5For-of15.ts, 3, 11))
->v : any, Symbol(v, Decl(ES5For-of15.ts, 2, 14))
+>x : any
+>v : any
     }
 }

tests/baselines/reference/ES5For-of16.symbols

@@ -0,0 +1,18 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of16.ts ===
+for (let v of []) {
+>v : Symbol(v, Decl(ES5For-of16.ts, 0, 8))
+
+    v;
+>v : Symbol(v, Decl(ES5For-of16.ts, 0, 8))
+
+    for (let v of []) {
+>v : Symbol(v, Decl(ES5For-of16.ts, 2, 12))
+
+        var x = v;
+>x : Symbol(x, Decl(ES5For-of16.ts, 3, 11))
+>v : Symbol(v, Decl(ES5For-of16.ts, 2, 12))
+
+        v++;
+>v : Symbol(v, Decl(ES5For-of16.ts, 2, 12))
+    }
+}

tests/baselines/reference/ES5For-of16.types

@@ -1,21 +1,21 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of16.ts ===
 for (let v of []) {
->v : any, Symbol(v, Decl(ES5For-of16.ts, 0, 8))
+>v : any
 >[] : undefined[]
 
     v;
->v : any, Symbol(v, Decl(ES5For-of16.ts, 0, 8))
+>v : any
 
     for (let v of []) {
->v : any, Symbol(v, Decl(ES5For-of16.ts, 2, 12))
+>v : any
 >[] : undefined[]
 
         var x = v;
->x : any, Symbol(x, Decl(ES5For-of16.ts, 3, 11))
->v : any, Symbol(v, Decl(ES5For-of16.ts, 2, 12))
+>x : any
+>v : any
 
         v++;
 >v++ : number
->v : any, Symbol(v, Decl(ES5For-of16.ts, 2, 12))
+>v : any
     }
 }

tests/baselines/reference/ES5For-of18.symbols

@@ -0,0 +1,14 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of18.ts ===
+for (let v of []) {
+>v : Symbol(v, Decl(ES5For-of18.ts, 0, 8))
+
+    v;
+>v : Symbol(v, Decl(ES5For-of18.ts, 0, 8))
+}
+for (let v of []) {
+>v : Symbol(v, Decl(ES5For-of18.ts, 3, 8))
+
+    v;
+>v : Symbol(v, Decl(ES5For-of18.ts, 3, 8))
+}
+

tests/baselines/reference/ES5For-of18.types

@@ -1,16 +1,16 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of18.ts ===
 for (let v of []) {
->v : any, Symbol(v, Decl(ES5For-of18.ts, 0, 8))
+>v : any
 >[] : undefined[]
 
     v;
->v : any, Symbol(v, Decl(ES5For-of18.ts, 0, 8))
+>v : any
 }
 for (let v of []) {
->v : any, Symbol(v, Decl(ES5For-of18.ts, 3, 8))
+>v : any
 >[] : undefined[]
 
     v;
->v : any, Symbol(v, Decl(ES5For-of18.ts, 3, 8))
+>v : any
 }
 

tests/baselines/reference/ES5For-of19.symbols

@@ -0,0 +1,19 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of19.ts ===
+for (let v of []) {
+>v : Symbol(v, Decl(ES5For-of19.ts, 0, 8))
+
+    v;
+>v : Symbol(v, Decl(ES5For-of19.ts, 0, 8))
+
+    function foo() {
+>foo : Symbol(foo, Decl(ES5For-of19.ts, 1, 6))
+
+        for (const v of []) {
+>v : Symbol(v, Decl(ES5For-of19.ts, 3, 18))
+
+            v;
+>v : Symbol(v, Decl(ES5For-of19.ts, 3, 18))
+        }
+    }
+}
+

tests/baselines/reference/ES5For-of19.types

@@ -1,20 +1,20 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of19.ts ===
 for (let v of []) {
->v : any, Symbol(v, Decl(ES5For-of19.ts, 0, 8))
+>v : any
 >[] : undefined[]
 
     v;
->v : any, Symbol(v, Decl(ES5For-of19.ts, 0, 8))
+>v : any
 
     function foo() {
->foo : () => void, Symbol(foo, Decl(ES5For-of19.ts, 1, 6))
+>foo : () => void
 
         for (const v of []) {
->v : any, Symbol(v, Decl(ES5For-of19.ts, 3, 18))
+>v : any
 >[] : undefined[]
 
             v;
->v : any, Symbol(v, Decl(ES5For-of19.ts, 3, 18))
+>v : any
         }
     }
 }

tests/baselines/reference/ES5For-of2.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of2.ts ===
+for (var v of []) {
+>v : Symbol(v, Decl(ES5For-of2.ts, 0, 8))
+
+    var x = v;
+>x : Symbol(x, Decl(ES5For-of2.ts, 1, 7))
+>v : Symbol(v, Decl(ES5For-of2.ts, 0, 8))
+}

tests/baselines/reference/ES5For-of2.types

@@ -1,9 +1,9 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of2.ts ===
 for (var v of []) {
->v : any, Symbol(v, Decl(ES5For-of2.ts, 0, 8))
+>v : any
 >[] : undefined[]
 
     var x = v;
->x : any, Symbol(x, Decl(ES5For-of2.ts, 1, 7))
->v : any, Symbol(v, Decl(ES5For-of2.ts, 0, 8))
+>x : any
+>v : any
 }

tests/baselines/reference/ES5For-of21.symbols

@@ -0,0 +1,7 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of21.ts ===
+for (let v of []) {
+>v : Symbol(v, Decl(ES5For-of21.ts, 0, 8))
+
+    for (let _i of []) { }
+>_i : Symbol(_i, Decl(ES5For-of21.ts, 1, 12))
+}

tests/baselines/reference/ES5For-of21.types

@@ -1,9 +1,9 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of21.ts ===
 for (let v of []) {
->v : any, Symbol(v, Decl(ES5For-of21.ts, 0, 8))
+>v : any
 >[] : undefined[]
 
     for (let _i of []) { }
->_i : any, Symbol(_i, Decl(ES5For-of21.ts, 1, 12))
+>_i : any
 >[] : undefined[]
 }

tests/baselines/reference/ES5For-of24.symbols

@@ -0,0 +1,11 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of24.ts ===
+var a = [1, 2, 3];
+>a : Symbol(a, Decl(ES5For-of24.ts, 0, 3))
+
+for (var v of a) {
+>v : Symbol(v, Decl(ES5For-of24.ts, 1, 8))
+>a : Symbol(a, Decl(ES5For-of24.ts, 0, 3))
+
+    let a = 0;
+>a : Symbol(a, Decl(ES5For-of24.ts, 2, 7))
+}

tests/baselines/reference/ES5For-of24.types

@@ -1,16 +1,16 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of24.ts ===
 var a = [1, 2, 3];
->a : number[], Symbol(a, Decl(ES5For-of24.ts, 0, 3))
+>a : number[]
 >[1, 2, 3] : number[]
 >1 : number
 >2 : number
 >3 : number
 
 for (var v of a) {
->v : number, Symbol(v, Decl(ES5For-of24.ts, 1, 8))
->a : number[], Symbol(a, Decl(ES5For-of24.ts, 0, 3))
+>v : number
+>a : number[]
 
     let a = 0;
->a : number, Symbol(a, Decl(ES5For-of24.ts, 2, 7))
+>a : number
 >0 : number
 }

tests/baselines/reference/ES5For-of25.symbols

@@ -0,0 +1,14 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of25.ts ===
+var a = [1, 2, 3];
+>a : Symbol(a, Decl(ES5For-of25.ts, 0, 3))
+
+for (var v of a) {
+>v : Symbol(v, Decl(ES5For-of25.ts, 1, 8))
+>a : Symbol(a, Decl(ES5For-of25.ts, 0, 3))
+
+    v;
+>v : Symbol(v, Decl(ES5For-of25.ts, 1, 8))
+
+    a;
+>a : Symbol(a, Decl(ES5For-of25.ts, 0, 3))
+}

tests/baselines/reference/ES5For-of25.types

@@ -1,18 +1,18 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of25.ts ===
 var a = [1, 2, 3];
->a : number[], Symbol(a, Decl(ES5For-of25.ts, 0, 3))
+>a : number[]
 >[1, 2, 3] : number[]
 >1 : number
 >2 : number
 >3 : number
 
 for (var v of a) {
->v : number, Symbol(v, Decl(ES5For-of25.ts, 1, 8))
->a : number[], Symbol(a, Decl(ES5For-of25.ts, 0, 3))
+>v : number
+>a : number[]
 
     v;
->v : number, Symbol(v, Decl(ES5For-of25.ts, 1, 8))
+>v : number
 
     a;
->a : number[], Symbol(a, Decl(ES5For-of25.ts, 0, 3))
+>a : number[]
 }

tests/baselines/reference/ES5For-of3.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of3.ts ===
+for (var v of ['a', 'b', 'c'])
+>v : Symbol(v, Decl(ES5For-of3.ts, 0, 8))
+
+    var x = v;
+>x : Symbol(x, Decl(ES5For-of3.ts, 1, 7))
+>v : Symbol(v, Decl(ES5For-of3.ts, 0, 8))
+

tests/baselines/reference/ES5For-of3.types

@@ -1,12 +1,12 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of3.ts ===
 for (var v of ['a', 'b', 'c'])
->v : string, Symbol(v, Decl(ES5For-of3.ts, 0, 8))
+>v : string
 >['a', 'b', 'c'] : string[]
 >'a' : string
 >'b' : string
 >'c' : string
 
     var x = v;
->x : string, Symbol(x, Decl(ES5For-of3.ts, 1, 7))
->v : string, Symbol(v, Decl(ES5For-of3.ts, 0, 8))
+>x : string
+>v : string
 

tests/baselines/reference/ES5For-of4.symbols

@@ -0,0 +1,12 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of4.ts ===
+for (var v of [])
+>v : Symbol(v, Decl(ES5For-of4.ts, 0, 8))
+
+    var x = v;
+>x : Symbol(x, Decl(ES5For-of4.ts, 1, 7))
+>v : Symbol(v, Decl(ES5For-of4.ts, 0, 8))
+
+var y = v;
+>y : Symbol(y, Decl(ES5For-of4.ts, 2, 3))
+>v : Symbol(v, Decl(ES5For-of4.ts, 0, 8))
+

tests/baselines/reference/ES5For-of4.types

@@ -1,13 +1,13 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of4.ts ===
 for (var v of [])
->v : any, Symbol(v, Decl(ES5For-of4.ts, 0, 8))
+>v : any
 >[] : undefined[]
 
     var x = v;
->x : any, Symbol(x, Decl(ES5For-of4.ts, 1, 7))
->v : any, Symbol(v, Decl(ES5For-of4.ts, 0, 8))
+>x : any
+>v : any
 
 var y = v;
->y : any, Symbol(y, Decl(ES5For-of4.ts, 2, 3))
->v : any, Symbol(v, Decl(ES5For-of4.ts, 0, 8))
+>y : any
+>v : any
 

tests/baselines/reference/ES5For-of5.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of5.ts ===
+for (var _a of []) {
+>_a : Symbol(_a, Decl(ES5For-of5.ts, 0, 8))
+
+    var x = _a;
+>x : Symbol(x, Decl(ES5For-of5.ts, 1, 7))
+>_a : Symbol(_a, Decl(ES5For-of5.ts, 0, 8))
+}

tests/baselines/reference/ES5For-of5.types

@@ -1,9 +1,9 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of5.ts ===
 for (var _a of []) {
->_a : any, Symbol(_a, Decl(ES5For-of5.ts, 0, 8))
+>_a : any
 >[] : undefined[]
 
     var x = _a;
->x : any, Symbol(x, Decl(ES5For-of5.ts, 1, 7))
->_a : any, Symbol(_a, Decl(ES5For-of5.ts, 0, 8))
+>x : any
+>_a : any
 }

tests/baselines/reference/ES5For-of6.symbols

@@ -0,0 +1,13 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of6.ts ===
+for (var w of []) {
+>w : Symbol(w, Decl(ES5For-of6.ts, 0, 8))
+
+    for (var v of []) {
+>v : Symbol(v, Decl(ES5For-of6.ts, 1, 12))
+
+        var x = [w, v];
+>x : Symbol(x, Decl(ES5For-of6.ts, 2, 11))
+>w : Symbol(w, Decl(ES5For-of6.ts, 0, 8))
+>v : Symbol(v, Decl(ES5For-of6.ts, 1, 12))
+    }
+}

tests/baselines/reference/ES5For-of6.types

@@ -1,16 +1,16 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of6.ts ===
 for (var w of []) {
->w : any, Symbol(w, Decl(ES5For-of6.ts, 0, 8))
+>w : any
 >[] : undefined[]
 
     for (var v of []) {
->v : any, Symbol(v, Decl(ES5For-of6.ts, 1, 12))
+>v : any
 >[] : undefined[]
 
         var x = [w, v];
->x : any[], Symbol(x, Decl(ES5For-of6.ts, 2, 11))
+>x : any[]
 >[w, v] : any[]
->w : any, Symbol(w, Decl(ES5For-of6.ts, 0, 8))
->v : any, Symbol(v, Decl(ES5For-of6.ts, 1, 12))
+>w : any
+>v : any
     }
 }

tests/baselines/reference/ES5For-of9.symbols

@@ -0,0 +1,24 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-of9.ts ===
+function foo() {
+>foo : Symbol(foo, Decl(ES5For-of9.ts, 0, 0))
+
+    return { x: 0 };
+>x : Symbol(x, Decl(ES5For-of9.ts, 1, 12))
+}
+for (foo().x of []) {
+>foo().x : Symbol(x, Decl(ES5For-of9.ts, 1, 12))
+>foo : Symbol(foo, Decl(ES5For-of9.ts, 0, 0))
+>x : Symbol(x, Decl(ES5For-of9.ts, 1, 12))
+
+    for (foo().x of []) {
+>foo().x : Symbol(x, Decl(ES5For-of9.ts, 1, 12))
+>foo : Symbol(foo, Decl(ES5For-of9.ts, 0, 0))
+>x : Symbol(x, Decl(ES5For-of9.ts, 1, 12))
+
+        var p = foo().x;
+>p : Symbol(p, Decl(ES5For-of9.ts, 5, 11))
+>foo().x : Symbol(x, Decl(ES5For-of9.ts, 1, 12))
+>foo : Symbol(foo, Decl(ES5For-of9.ts, 0, 0))
+>x : Symbol(x, Decl(ES5For-of9.ts, 1, 12))
+    }
+}

tests/baselines/reference/ES5For-of9.types

@@ -1,31 +1,31 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-of9.ts ===
 function foo() {
->foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of9.ts, 0, 0))
+>foo : () => { x: number; }
 
     return { x: 0 };
 >{ x: 0 } : { x: number; }
->x : number, Symbol(x, Decl(ES5For-of9.ts, 1, 12))
+>x : number
 >0 : number
 }
 for (foo().x of []) {
->foo().x : number, Symbol(x, Decl(ES5For-of9.ts, 1, 12))
+>foo().x : number
 >foo() : { x: number; }
->foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of9.ts, 0, 0))
->x : number, Symbol(x, Decl(ES5For-of9.ts, 1, 12))
+>foo : () => { x: number; }
+>x : number
 >[] : undefined[]
 
     for (foo().x of []) {
->foo().x : number, Symbol(x, Decl(ES5For-of9.ts, 1, 12))
+>foo().x : number
 >foo() : { x: number; }
->foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of9.ts, 0, 0))
->x : number, Symbol(x, Decl(ES5For-of9.ts, 1, 12))
+>foo : () => { x: number; }
+>x : number
 >[] : undefined[]
 
         var p = foo().x;
->p : number, Symbol(p, Decl(ES5For-of9.ts, 5, 11))
->foo().x : number, Symbol(x, Decl(ES5For-of9.ts, 1, 12))
+>p : number
+>foo().x : number
 >foo() : { x: number; }
->foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of9.ts, 0, 0))
->x : number, Symbol(x, Decl(ES5For-of9.ts, 1, 12))
+>foo : () => { x: number; }
+>x : number
     }
 }

tests/baselines/reference/ES5For-ofTypeCheck1.symbols

@@ -0,0 +1,4 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck1.ts ===
+for (var v of "") { }
+>v : Symbol(v, Decl(ES5For-ofTypeCheck1.ts, 0, 8))
+

tests/baselines/reference/ES5For-ofTypeCheck1.types

@@ -1,5 +1,5 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck1.ts ===
 for (var v of "") { }
->v : string, Symbol(v, Decl(ES5For-ofTypeCheck1.ts, 0, 8))
+>v : string
 >"" : string
 

tests/baselines/reference/ES5For-ofTypeCheck2.symbols

@@ -0,0 +1,4 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck2.ts ===
+for (var v of [true]) { }
+>v : Symbol(v, Decl(ES5For-ofTypeCheck2.ts, 0, 8))
+

tests/baselines/reference/ES5For-ofTypeCheck2.types

@@ -1,6 +1,6 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck2.ts ===
 for (var v of [true]) { }
->v : boolean, Symbol(v, Decl(ES5For-ofTypeCheck2.ts, 0, 8))
+>v : boolean
 >[true] : boolean[]
 >true : boolean
 

tests/baselines/reference/ES5For-ofTypeCheck3.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck3.ts ===
+var tuple: [string, number] = ["", 0];
+>tuple : Symbol(tuple, Decl(ES5For-ofTypeCheck3.ts, 0, 3))
+
+for (var v of tuple) { }
+>v : Symbol(v, Decl(ES5For-ofTypeCheck3.ts, 1, 8))
+>tuple : Symbol(tuple, Decl(ES5For-ofTypeCheck3.ts, 0, 3))
+

tests/baselines/reference/ES5For-ofTypeCheck3.types

@@ -1,11 +1,11 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck3.ts ===
 var tuple: [string, number] = ["", 0];
->tuple : [string, number], Symbol(tuple, Decl(ES5For-ofTypeCheck3.ts, 0, 3))
+>tuple : [string, number]
 >["", 0] : [string, number]
 >"" : string
 >0 : number
 
 for (var v of tuple) { }
->v : string | number, Symbol(v, Decl(ES5For-ofTypeCheck3.ts, 1, 8))
->tuple : [string, number], Symbol(tuple, Decl(ES5For-ofTypeCheck3.ts, 0, 3))
+>v : string | number
+>tuple : [string, number]
 

tests/baselines/reference/ES5For-ofTypeCheck4.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck4.ts ===
+var union: string | string[];
+>union : Symbol(union, Decl(ES5For-ofTypeCheck4.ts, 0, 3))
+
+for (const v of union) { }
+>v : Symbol(v, Decl(ES5For-ofTypeCheck4.ts, 1, 10))
+>union : Symbol(union, Decl(ES5For-ofTypeCheck4.ts, 0, 3))
+

tests/baselines/reference/ES5For-ofTypeCheck4.types

@@ -1,8 +1,8 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck4.ts ===
 var union: string | string[];
->union : string | string[], Symbol(union, Decl(ES5For-ofTypeCheck4.ts, 0, 3))
+>union : string | string[]
 
 for (const v of union) { }
->v : string, Symbol(v, Decl(ES5For-ofTypeCheck4.ts, 1, 10))
->union : string | string[], Symbol(union, Decl(ES5For-ofTypeCheck4.ts, 0, 3))
+>v : string
+>union : string | string[]
 

tests/baselines/reference/ES5For-ofTypeCheck5.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck5.ts ===
+var union: string | number[];
+>union : Symbol(union, Decl(ES5For-ofTypeCheck5.ts, 0, 3))
+
+for (var v of union) { }
+>v : Symbol(v, Decl(ES5For-ofTypeCheck5.ts, 1, 8))
+>union : Symbol(union, Decl(ES5For-ofTypeCheck5.ts, 0, 3))
+

tests/baselines/reference/ES5For-ofTypeCheck5.types

@@ -1,8 +1,8 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck5.ts ===
 var union: string | number[];
->union : string | number[], Symbol(union, Decl(ES5For-ofTypeCheck5.ts, 0, 3))
+>union : string | number[]
 
 for (var v of union) { }
->v : string | number, Symbol(v, Decl(ES5For-ofTypeCheck5.ts, 1, 8))
->union : string | number[], Symbol(union, Decl(ES5For-ofTypeCheck5.ts, 0, 3))
+>v : string | number
+>union : string | number[]
 

tests/baselines/reference/ES5For-ofTypeCheck6.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck6.ts ===
+var union: string[] | number[];
+>union : Symbol(union, Decl(ES5For-ofTypeCheck6.ts, 0, 3))
+
+for (var v of union) { }
+>v : Symbol(v, Decl(ES5For-ofTypeCheck6.ts, 1, 8))
+>union : Symbol(union, Decl(ES5For-ofTypeCheck6.ts, 0, 3))
+

tests/baselines/reference/ES5For-ofTypeCheck6.types

@@ -1,8 +1,8 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck6.ts ===
 var union: string[] | number[];
->union : string[] | number[], Symbol(union, Decl(ES5For-ofTypeCheck6.ts, 0, 3))
+>union : string[] | number[]
 
 for (var v of union) { }
->v : string | number, Symbol(v, Decl(ES5For-ofTypeCheck6.ts, 1, 8))
->union : string[] | number[], Symbol(union, Decl(ES5For-ofTypeCheck6.ts, 0, 3))
+>v : string | number
+>union : string[] | number[]
 

tests/baselines/reference/ES5SymbolType1.symbols

@@ -0,0 +1,9 @@
+=== tests/cases/conformance/Symbols/ES5SymbolType1.ts ===
+var s: symbol;
+>s : Symbol(s, Decl(ES5SymbolType1.ts, 0, 3))
+
+s.toString();
+>s.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>s : Symbol(s, Decl(ES5SymbolType1.ts, 0, 3))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+

tests/baselines/reference/ES5SymbolType1.types

@@ -1,10 +1,10 @@
 === tests/cases/conformance/Symbols/ES5SymbolType1.ts ===
 var s: symbol;
->s : symbol, Symbol(s, Decl(ES5SymbolType1.ts, 0, 3))
+>s : symbol
 
 s.toString();
 >s.toString() : string
->s.toString : () => string, Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
->s : symbol, Symbol(s, Decl(ES5SymbolType1.ts, 0, 3))
->toString : () => string, Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>s.toString : () => string
+>s : symbol
+>toString : () => string
 

tests/baselines/reference/EnumAndModuleWithSameNameAndCommonRoot.symbols

@@ -0,0 +1,42 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/EnumAndModuleWithSameNameAndCommonRoot.ts ===
+enum enumdule {
+>enumdule : Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
+
+    Red, Blue
+>Red : Symbol(enumdule.Red, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 15))
+>Blue : Symbol(enumdule.Blue, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 1, 8))
+}
+
+module enumdule {
+>enumdule : Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
+
+    export class Point {
+>Point : Symbol(Point, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 4, 17))
+
+        constructor(public x: number, public y: number) { }
+>x : Symbol(x, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 7, 20))
+>y : Symbol(y, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 7, 37))
+    }
+}
+
+var x: enumdule;
+>x : Symbol(x, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 11, 3), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 12, 3))
+>enumdule : Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
+
+var x = enumdule.Red;
+>x : Symbol(x, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 11, 3), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 12, 3))
+>enumdule.Red : Symbol(enumdule.Red, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 15))
+>enumdule : Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
+>Red : Symbol(enumdule.Red, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 15))
+
+var y: { x: number; y: number };
+>y : Symbol(y, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 14, 3), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 15, 3))
+>x : Symbol(x, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 14, 8))
+>y : Symbol(y, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 14, 19))
+
+var y = new enumdule.Point(0, 0);
+>y : Symbol(y, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 14, 3), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 15, 3))
+>enumdule.Point : Symbol(enumdule.Point, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 4, 17))
+>enumdule : Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
+>Point : Symbol(enumdule.Point, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 4, 17))
+

tests/baselines/reference/EnumAndModuleWithSameNameAndCommonRoot.types

@@ -1,45 +1,45 @@
 === tests/cases/conformance/internalModules/DeclarationMerging/EnumAndModuleWithSameNameAndCommonRoot.ts ===
 enum enumdule {
->enumdule : enumdule, Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
+>enumdule : enumdule
 
     Red, Blue
->Red : enumdule, Symbol(enumdule.Red, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 15))
->Blue : enumdule, Symbol(enumdule.Blue, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 1, 8))
+>Red : enumdule
+>Blue : enumdule
 }
 
 module enumdule {
->enumdule : typeof enumdule, Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
+>enumdule : typeof enumdule
 
     export class Point {
->Point : Point, Symbol(Point, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 4, 17))
+>Point : Point
 
         constructor(public x: number, public y: number) { }
->x : number, Symbol(x, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 7, 20))
->y : number, Symbol(y, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 7, 37))
+>x : number
+>y : number
     }
 }
 
 var x: enumdule;
->x : enumdule, Symbol(x, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 11, 3), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 12, 3))
->enumdule : enumdule, Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
+>x : enumdule
+>enumdule : enumdule
 
 var x = enumdule.Red;
->x : enumdule, Symbol(x, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 11, 3), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 12, 3))
->enumdule.Red : enumdule, Symbol(enumdule.Red, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 15))
->enumdule : typeof enumdule, Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
->Red : enumdule, Symbol(enumdule.Red, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 15))
+>x : enumdule
+>enumdule.Red : enumdule
+>enumdule : typeof enumdule
+>Red : enumdule
 
 var y: { x: number; y: number };
->y : { x: number; y: number; }, Symbol(y, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 14, 3), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 15, 3))
->x : number, Symbol(x, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 14, 8))
->y : number, Symbol(y, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 14, 19))
+>y : { x: number; y: number; }
+>x : number
+>y : number
 
 var y = new enumdule.Point(0, 0);
->y : { x: number; y: number; }, Symbol(y, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 14, 3), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 15, 3))
+>y : { x: number; y: number; }
 >new enumdule.Point(0, 0) : enumdule.Point
->enumdule.Point : typeof enumdule.Point, Symbol(enumdule.Point, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 4, 17))
->enumdule : typeof enumdule, Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
->Point : typeof enumdule.Point, Symbol(enumdule.Point, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 4, 17))
+>enumdule.Point : typeof enumdule.Point
+>enumdule : typeof enumdule
+>Point : typeof enumdule.Point
 >0 : number
 >0 : number
 

tests/baselines/reference/ExportClassWhichExtendsInterfaceWithInaccessibleType.symbols

@@ -0,0 +1,38 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWhichExtendsInterfaceWithInaccessibleType.ts ===
+module A {
+>A : Symbol(A, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 0))
+
+    interface Point {
+>Point : Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))
+
+        x: number;
+>x : Symbol(x, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 2, 21))
+
+        y: number;
+>y : Symbol(y, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 3, 18))
+
+        fromOrigin(p: Point): number;
+>fromOrigin : Symbol(fromOrigin, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 4, 18))
+>p : Symbol(p, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 6, 19))
+>Point : Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))
+    }
+
+    export class Point2d implements Point {
+>Point2d : Symbol(Point2d, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 7, 5))
+>Point : Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))
+
+        constructor(public x: number, public y: number) { }
+>x : Symbol(x, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 20))
+>y : Symbol(y, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 37))
+
+        fromOrigin(p: Point) {
+>fromOrigin : Symbol(fromOrigin, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 59))
+>p : Symbol(p, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 12, 19))
+>Point : Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))
+
+            return 1;
+        }
+    }
+}
+
+

tests/baselines/reference/ExportClassWhichExtendsInterfaceWithInaccessibleType.types

@@ -1,34 +1,34 @@
 === tests/cases/conformance/internalModules/exportDeclarations/ExportClassWhichExtendsInterfaceWithInaccessibleType.ts ===
 module A {
->A : typeof A, Symbol(A, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 0))
+>A : typeof A
 
     interface Point {
->Point : Point, Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))
+>Point : Point
 
         x: number;
->x : number, Symbol(x, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 2, 21))
+>x : number
 
         y: number;
->y : number, Symbol(y, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 3, 18))
+>y : number
 
         fromOrigin(p: Point): number;
->fromOrigin : (p: Point) => number, Symbol(fromOrigin, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 4, 18))
->p : Point, Symbol(p, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 6, 19))
->Point : Point, Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))
+>fromOrigin : (p: Point) => number
+>p : Point
+>Point : Point
     }
 
     export class Point2d implements Point {
->Point2d : Point2d, Symbol(Point2d, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 7, 5))
->Point : Point, Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))
+>Point2d : Point2d
+>Point : Point
 
         constructor(public x: number, public y: number) { }
->x : number, Symbol(x, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 20))
->y : number, Symbol(y, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 37))
+>x : number
+>y : number
 
         fromOrigin(p: Point) {
->fromOrigin : (p: Point) => number, Symbol(fromOrigin, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 59))
->p : Point, Symbol(p, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 12, 19))
->Point : Point, Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))
+>fromOrigin : (p: Point) => number
+>p : Point
+>Point : Point
 
             return 1;
 >1 : number

tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols

@@ -0,0 +1,48 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts ===
+module A {
+>A : Symbol(A, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 0))
+
+    export class Point {
+>Point : Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
+
+        x: number;
+>x : Symbol(x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 2, 24))
+
+        y: number;
+>y : Symbol(y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 3, 18))
+    }
+
+    export var Origin: Point = { x: 0, y: 0 };
+>Origin : Symbol(Origin, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 14))
+>Point : Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
+>x : Symbol(x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 32))
+>y : Symbol(y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 38))
+
+    export class Point3d extends Point {
+>Point3d : Symbol(Point3d, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 46))
+>Point : Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
+
+        z: number;
+>z : Symbol(z, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 9, 40))
+    }
+
+    export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
+>Origin3d : Symbol(Origin3d, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 14))
+>Point3d : Symbol(Point3d, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 46))
+>x : Symbol(x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 36))
+>y : Symbol(y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 42))
+>z : Symbol(z, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 48))
+
+    export class Line<TPoint extends Point>{
+>Line : Symbol(Line, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 56))
+>TPoint : Symbol(TPoint, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 22))
+>Point : Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
+
+        constructor(public start: TPoint, public end: TPoint) { }
+>start : Symbol(start, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 20))
+>TPoint : Symbol(TPoint, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 22))
+>end : Symbol(end, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 41))
+>TPoint : Symbol(TPoint, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 22))
+    }
+}
+

tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types

@@ -1,55 +1,55 @@
 === tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts ===
 module A {
->A : typeof A, Symbol(A, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 0))
+>A : typeof A
 
     export class Point {
->Point : Point, Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
+>Point : Point
 
         x: number;
->x : number, Symbol(x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 2, 24))
+>x : number
 
         y: number;
->y : number, Symbol(y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 3, 18))
+>y : number
     }
 
     export var Origin: Point = { x: 0, y: 0 };
->Origin : Point, Symbol(Origin, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 14))
->Point : Point, Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
+>Origin : Point
+>Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
->x : number, Symbol(x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 32))
+>x : number
 >0 : number
->y : number, Symbol(y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 38))
+>y : number
 >0 : number
 
     export class Point3d extends Point {
->Point3d : Point3d, Symbol(Point3d, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 46))
->Point : Point, Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
+>Point3d : Point3d
+>Point : Point
 
         z: number;
->z : number, Symbol(z, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 9, 40))
+>z : number
     }
 
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
->Origin3d : Point3d, Symbol(Origin3d, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 14))
->Point3d : Point3d, Symbol(Point3d, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 46))
+>Origin3d : Point3d
+>Point3d : Point3d
 >{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
->x : number, Symbol(x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 36))
+>x : number
 >0 : number
->y : number, Symbol(y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 42))
+>y : number
 >0 : number
->z : number, Symbol(z, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 48))
+>z : number
 >0 : number
 
     export class Line<TPoint extends Point>{
->Line : Line<TPoint>, Symbol(Line, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 56))
->TPoint : TPoint, Symbol(TPoint, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 22))
->Point : Point, Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
+>Line : Line<TPoint>
+>TPoint : TPoint
+>Point : Point
 
         constructor(public start: TPoint, public end: TPoint) { }
->start : TPoint, Symbol(start, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 20))
->TPoint : TPoint, Symbol(TPoint, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 22))
->end : TPoint, Symbol(end, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 41))
->TPoint : TPoint, Symbol(TPoint, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 22))
+>start : TPoint
+>TPoint : TPoint
+>end : TPoint
+>TPoint : TPoint
     }
 }
 

tests/baselines/reference/ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.symbols

@@ -0,0 +1,28 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts ===
+module A {
+>A : Symbol(A, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 0))
+
+    class Point {
+>Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 10))
+
+        x: number;
+>x : Symbol(x, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 2, 17))
+
+        y: number;
+>y : Symbol(y, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 3, 18))
+    }
+
+    export class points {
+>points : Symbol(points, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 5, 5))
+
+        [idx: number]: Point;
+>idx : Symbol(idx, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 9, 9))
+>Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 10))
+
+        [idx: string]: Point;
+>idx : Symbol(idx, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 10, 9))
+>Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 10))
+    }
+}
+
+

tests/baselines/reference/ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.types

@@ -1,27 +1,27 @@
 === tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts ===
 module A {
->A : typeof A, Symbol(A, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 0))
+>A : typeof A
 
     class Point {
->Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 10))
+>Point : Point
 
         x: number;
->x : number, Symbol(x, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 2, 17))
+>x : number
 
         y: number;
->y : number, Symbol(y, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 3, 18))
+>y : number
     }
 
     export class points {
->points : points, Symbol(points, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 5, 5))
+>points : points
 
         [idx: number]: Point;
->idx : number, Symbol(idx, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 9, 9))
->Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 10))
+>idx : number
+>Point : Point
 
         [idx: string]: Point;
->idx : string, Symbol(idx, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 10, 9))
->Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 10))
+>idx : string
+>Point : Point
     }
 }
 

tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.symbols

@@ -0,0 +1,58 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts ===
+module A {
+>A : Symbol(A, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 0))
+
+    class Point {
+>Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
+
+        x: number;
+>x : Symbol(x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 2, 17))
+
+        y: number;
+>y : Symbol(y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 3, 18))
+    }
+
+    export var Origin: Point = { x: 0, y: 0 };
+>Origin : Symbol(Origin, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 14))
+>Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
+>x : Symbol(x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 32))
+>y : Symbol(y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 38))
+
+    export class Point3d extends Point {
+>Point3d : Symbol(Point3d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 46))
+>Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
+
+        z: number;
+>z : Symbol(z, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 9, 40))
+    }
+
+    export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
+>Origin3d : Symbol(Origin3d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 14))
+>Point3d : Symbol(Point3d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 46))
+>x : Symbol(x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 36))
+>y : Symbol(y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 42))
+>z : Symbol(z, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 48))
+
+    export class Line<TPoint extends Point>{
+>Line : Symbol(Line, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 56))
+>TPoint : Symbol(TPoint, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 22))
+>Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
+
+        constructor(public start: TPoint, public end: TPoint) { }
+>start : Symbol(start, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 20))
+>TPoint : Symbol(TPoint, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 22))
+>end : Symbol(end, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 41))
+>TPoint : Symbol(TPoint, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 22))
+
+        static fromorigin2d(p: Point): Line<Point>{
+>fromorigin2d : Symbol(Line.fromorigin2d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 65))
+>p : Symbol(p, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 18, 28))
+>Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
+>Line : Symbol(Line, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 56))
+>Point : Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
+
+            return null;
+        }
+    }
+}
+

tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.types

@@ -1,62 +1,62 @@
 === tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts ===
 module A {
->A : typeof A, Symbol(A, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 0))
+>A : typeof A
 
     class Point {
->Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
+>Point : Point
 
         x: number;
->x : number, Symbol(x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 2, 17))
+>x : number
 
         y: number;
->y : number, Symbol(y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 3, 18))
+>y : number
     }
 
     export var Origin: Point = { x: 0, y: 0 };
->Origin : Point, Symbol(Origin, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 14))
->Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
+>Origin : Point
+>Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
->x : number, Symbol(x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 32))
+>x : number
 >0 : number
->y : number, Symbol(y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 38))
+>y : number
 >0 : number
 
     export class Point3d extends Point {
->Point3d : Point3d, Symbol(Point3d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 46))
->Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
+>Point3d : Point3d
+>Point : Point
 
         z: number;
->z : number, Symbol(z, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 9, 40))
+>z : number
     }
 
     export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
->Origin3d : Point3d, Symbol(Origin3d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 14))
->Point3d : Point3d, Symbol(Point3d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 46))
+>Origin3d : Point3d
+>Point3d : Point3d
 >{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
->x : number, Symbol(x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 36))
+>x : number
 >0 : number
->y : number, Symbol(y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 42))
+>y : number
 >0 : number
->z : number, Symbol(z, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 48))
+>z : number
 >0 : number
 
     export class Line<TPoint extends Point>{
->Line : Line<TPoint>, Symbol(Line, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 56))
->TPoint : TPoint, Symbol(TPoint, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 22))
->Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
+>Line : Line<TPoint>
+>TPoint : TPoint
+>Point : Point
 
         constructor(public start: TPoint, public end: TPoint) { }
->start : TPoint, Symbol(start, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 20))
->TPoint : TPoint, Symbol(TPoint, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 22))
->end : TPoint, Symbol(end, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 41))
->TPoint : TPoint, Symbol(TPoint, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 22))
+>start : TPoint
+>TPoint : TPoint
+>end : TPoint
+>TPoint : TPoint
 
         static fromorigin2d(p: Point): Line<Point>{
->fromorigin2d : (p: Point) => Line<Point>, Symbol(Line.fromorigin2d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 65))
->p : Point, Symbol(p, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 18, 28))
->Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
->Line : Line<TPoint>, Symbol(Line, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 56))
->Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
+>fromorigin2d : (p: Point) => Line<Point>
+>p : Point
+>Point : Point
+>Line : Line<TPoint>
+>Point : Point
 
             return null;
 >null : null

tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.symbols

@@ -0,0 +1,37 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts ===
+module A {
+>A : Symbol(A, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 0))
+
+    export class Point {
+>Point : Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))
+
+        x: number;
+>x : Symbol(x, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 2, 24))
+
+        y: number;
+>y : Symbol(y, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 3, 18))
+    }
+
+    export class Line {
+>Line : Symbol(Line, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 5, 5))
+
+        constructor(public start: Point, public end: Point) { }
+>start : Symbol(start, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 8, 20))
+>Point : Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))
+>end : Symbol(end, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 8, 40))
+>Point : Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))
+    }
+
+    export function fromOrigin(p: Point): Line {
+>fromOrigin : Symbol(fromOrigin, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 9, 5))
+>p : Symbol(p, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 11, 31))
+>Point : Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))
+>Line : Symbol(Line, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 5, 5))
+
+        return new Line({ x: 0, y: 0 }, p);
+>Line : Symbol(Line, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 5, 5))
+>x : Symbol(x, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 12, 25))
+>y : Symbol(y, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 12, 31))
+>p : Symbol(p, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 11, 31))
+    }
+}

tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.types

@@ -1,41 +1,41 @@
 === tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts ===
 module A {
->A : typeof A, Symbol(A, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 0))
+>A : typeof A
 
     export class Point {
->Point : Point, Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))
+>Point : Point
 
         x: number;
->x : number, Symbol(x, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 2, 24))
+>x : number
 
         y: number;
->y : number, Symbol(y, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 3, 18))
+>y : number
     }
 
     export class Line {
->Line : Line, Symbol(Line, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 5, 5))
+>Line : Line
 
         constructor(public start: Point, public end: Point) { }
->start : Point, Symbol(start, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 8, 20))
->Point : Point, Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))
->end : Point, Symbol(end, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 8, 40))
->Point : Point, Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))
+>start : Point
+>Point : Point
+>end : Point
+>Point : Point
     }
 
     export function fromOrigin(p: Point): Line {
->fromOrigin : (p: Point) => Line, Symbol(fromOrigin, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 9, 5))
->p : Point, Symbol(p, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 11, 31))
->Point : Point, Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))
->Line : Line, Symbol(Line, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 5, 5))
+>fromOrigin : (p: Point) => Line
+>p : Point
+>Point : Point
+>Line : Line
 
         return new Line({ x: 0, y: 0 }, p);
 >new Line({ x: 0, y: 0 }, p) : Line
->Line : typeof Line, Symbol(Line, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 5, 5))
+>Line : typeof Line
 >{ x: 0, y: 0 } : { x: number; y: number; }
->x : number, Symbol(x, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 12, 25))
+>x : number
 >0 : number
->y : number, Symbol(y, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 12, 31))
+>y : number
 >0 : number
->p : Point, Symbol(p, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 11, 31))
+>p : Point
     }
 }

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.symbols

@@ -0,0 +1,37 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts ===
+module A {
+>A : Symbol(A, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 0, 0))
+
+    class Point {
+>Point : Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 0, 10))
+
+        x: number;
+>x : Symbol(x, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 2, 17))
+
+        y: number;
+>y : Symbol(y, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 3, 18))
+    }
+
+    export class Line {
+>Line : Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 5, 5))
+
+        constructor(public start: Point, public end: Point) { }
+>start : Symbol(start, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 8, 20))
+>Point : Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 0, 10))
+>end : Symbol(end, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 8, 40))
+>Point : Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 0, 10))
+    }
+
+    export function fromOrigin(p: Point): Line {
+>fromOrigin : Symbol(fromOrigin, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 9, 5))
+>p : Symbol(p, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 11, 31))
+>Point : Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 0, 10))
+>Line : Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 5, 5))
+
+        return new Line({ x: 0, y: 0 }, p);
+>Line : Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 5, 5))
+>x : Symbol(x, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 12, 25))
+>y : Symbol(y, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 12, 31))
+>p : Symbol(p, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 11, 31))
+    }
+}