Fix merge conflicts

Author: RyanCavanaugh

src/compiler/binder.ts

@@ -252,7 +252,6 @@ namespace ts {
                     return "p" + index;
 
                 case SyntaxKind.BinaryExpression:
-                    Debug.assert(isModuleExportsAssignment(node));
                     return "__jsExports";
             }
         }

src/compiler/checker.ts

@@ -164,7 +164,6 @@ namespace ts {
         let getGlobalPromiseConstructorLikeType: () => ObjectType;
         let getGlobalThenableType: () => ObjectType;
 
-        let jsxElementClassType: Type;
         let deferredNodes: Node[];
 
         const tupleTypes: Map<TupleType> = {};
@@ -3941,10 +3940,6 @@ namespace ts {
             return result;
         }
 
-        function isRestOrOptionalParameter(node: ParameterDeclaration, skipSignatureCheck?: boolean) {
-            return isRestParameter(node) || isOptionalParameter(node, skipSignatureCheck);
-        }
-
         function isOptionalParameter(node: ParameterDeclaration, skipSignatureCheck?: boolean) {
             if (node.parserContextFlags & ParserContextFlags.JavaScriptFile) {
                 if (node.type && node.type.kind === SyntaxKind.JSDocOptionalType) {
@@ -4014,7 +4009,6 @@ namespace ts {
                 let minArgumentCount = -1;
                 const isJSConstructSignature = isJSDocConstructSignature(declaration);
                 let returnType: Type = undefined;
-                let typePredicate: TypePredicate = undefined;
 
                 // If this is a JSDoc construct signature, then skip the first parameter in the 
                 // parameter list.  The first parameter represents the return type of the construct
@@ -4049,16 +4043,11 @@ namespace ts {
                     minArgumentCount = declaration.parameters.length;
                 }
 
-<<<<<<< HEAD
                 if (isJSConstructSignature) {
                     minArgumentCount--;
                     returnType = getTypeFromTypeNode(declaration.parameters[0].type);
                 }
                 else if (classType) {
-=======
-                let returnType: Type;
-                if (classType) {
->>>>>>> upstream/master
                     returnType = classType;
                 }
                 else if (declaration.type) {
@@ -4327,61 +4316,6 @@ namespace ts {
             return type;
         }
 
-<<<<<<< HEAD
-        function isTypeParameterReferenceIllegalInConstraint(
-            typeReferenceNode: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference,
-            typeParameterSymbol: Symbol): boolean {
-
-            const links = getNodeLinks(typeReferenceNode);
-            if (links.isIllegalTypeReferenceInConstraint !== undefined) {
-                return links.isIllegalTypeReferenceInConstraint;
-            }
-
-            // bubble up to the declaration
-            let currentNode: Node = typeReferenceNode;
-            // forEach === exists
-            while (!forEach(typeParameterSymbol.declarations, d => getTypeParameterOwner(d) === currentNode.parent)) {
-                currentNode = currentNode.parent;
-            }
-            // if last step was made from the type parameter this means that path has started somewhere in constraint which is illegal
-            links.isIllegalTypeReferenceInConstraint = currentNode.kind === SyntaxKind.TypeParameter;
-            return links.isIllegalTypeReferenceInConstraint;
-        }
-
-        function checkTypeParameterHasIllegalReferencesInConstraint(typeParameter: TypeParameterDeclaration): void {
-            let typeParameterSymbol: Symbol;
-            function check(n: Node): void {
-                if (n.kind === SyntaxKind.TypeReference && (<TypeReferenceNode>n).typeName.kind === SyntaxKind.Identifier) {
-                    const links = getNodeLinks(n);
-                    if (links.isIllegalTypeReferenceInConstraint === undefined) {
-                        const symbol = resolveName(typeParameter, (<Identifier>(<TypeReferenceNode>n).typeName).text, SymbolFlags.Type, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined);
-                        if (symbol && (symbol.flags & SymbolFlags.TypeParameter)) {
-                            // TypeScript 1.0 spec (April 2014): 3.4.1
-                            // Type parameters declared in a particular type parameter list
-                            // may not be referenced in constraints in that type parameter list
-
-                            // symbol.declaration.parent === typeParameter.parent
-                            // -> typeParameter and symbol.declaration originate from the same type parameter list
-                            // -> illegal for all declarations in symbol
-                            // forEach === exists
-                            links.isIllegalTypeReferenceInConstraint = forEach(symbol.declarations, d => d.parent === typeParameter.parent);
-                        }
-                    }
-                    if (links.isIllegalTypeReferenceInConstraint) {
-                        error(typeParameter, Diagnostics.Constraint_of_a_type_parameter_cannot_reference_any_type_parameter_from_the_same_type_parameter_list);
-                    }
-                }
-                forEachChild(n, check);
-            }
-
-            if (typeParameter.constraint) {
-                typeParameterSymbol = getSymbolOfNode(typeParameter);
-                check(typeParameter.constraint);
-            }
-        }
-
-=======
->>>>>>> upstream/master
         // Get type from reference to class or interface
         function getTypeFromClassOrInterfaceReference(node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference, symbol: Symbol): Type {
             const type = <InterfaceType>getDeclaredTypeOfSymbol(symbol);
@@ -4428,18 +4362,7 @@ namespace ts {
         }
 
         // Get type from reference to named type that cannot be generic (enum or type parameter)
-<<<<<<< HEAD
         function getTypeFromNonGenericTypeReference(node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference, symbol: Symbol): Type {
-            if (symbol.flags & SymbolFlags.TypeParameter && isTypeParameterReferenceIllegalInConstraint(node, symbol)) {
-                // TypeScript 1.0 spec (April 2014): 3.4.1
-                // Type parameters declared in a particular type parameter list
-                // may not be referenced in constraints in that type parameter list
-                // Implementation: such type references are resolved to 'unknown' type that usually denotes error
-                return unknownType;
-            }
-=======
-        function getTypeFromNonGenericTypeReference(node: TypeReferenceNode | ExpressionWithTypeArguments, symbol: Symbol): Type {
->>>>>>> upstream/master
             if (node.typeArguments) {
                 error(node, Diagnostics.Type_0_is_not_generic, symbolToString(symbol));
                 return unknownType;
@@ -7421,12 +7344,13 @@ namespace ts {
                 return container.flags & NodeFlags.Static ? getTypeOfSymbol(symbol) : (<InterfaceType>getDeclaredTypeOfSymbol(symbol)).thisType;
             }
 
-<<<<<<< HEAD
             if (container.parserContextFlags & ParserContextFlags.JavaScriptFile) {
                 const type = getTypeForThisExpressionFromJSDoc(container);
                 if (type && type !== unknownType) {
                     return type;
-=======
+                }
+            }
+
             // If this is a function in a JS file, it might be a class method. Check if it's the RHS
             // of a x.prototype.y = function [name]() { .... }
             if (isInJavaScriptFile(node) && container.kind === SyntaxKind.FunctionExpression) {
@@ -7440,7 +7364,6 @@ namespace ts {
                     if (classSymbol && classSymbol.members && (classSymbol.flags & SymbolFlags.Function)) {
                         return getInferredClassType(classSymbol);
                     }
->>>>>>> upstream/master
                 }
             }
 

src/compiler/parser.ts

@@ -6041,7 +6041,6 @@ namespace ts {
                     let name: Identifier;
                     let isBracketed: boolean;
                     // Looking for something like '[foo]' or 'foo'
-                    const startPos = scanner.getTextPos();
                     if (parseOptionalToken(SyntaxKind.OpenBracketToken)) {
                         name = scanJsDocIdentifier();
                         nextJSDocToken();

src/compiler/scanner.ts

@@ -1681,31 +1681,31 @@ namespace ts {
                 }
                 else {
                     if (ch === CharacterCodes.at) {
-                        return pos++, token = SyntaxKind.AtToken;
+                        return pos += 1, token = SyntaxKind.AtToken;
                     }
                     else if (isLineBreak(ch)) {
-                        return pos++, token = SyntaxKind.NewLineTrivia;
+                        return pos += 1, token = SyntaxKind.NewLineTrivia;
                     }
                     else if (ch === CharacterCodes.asterisk) {
-                        return pos++, token = SyntaxKind.AsteriskToken;
+                        return pos += 1, token = SyntaxKind.AsteriskToken;
                     }
                     else if (ch === CharacterCodes.openBrace) {
-                        return pos++, token = SyntaxKind.OpenBraceToken;
+                        return pos += 1, token = SyntaxKind.OpenBraceToken;
                     }
                     else if (ch === CharacterCodes.closeBrace) {
-                        return pos++, token = SyntaxKind.CloseBraceToken;
+                        return pos += 1, token = SyntaxKind.CloseBraceToken;
                     }
                     else if (ch === CharacterCodes.openBracket) {
-                        return pos++, token = SyntaxKind.OpenBracketToken;
+                        return pos += 1, token = SyntaxKind.OpenBracketToken;
                     }
                     else if (ch === CharacterCodes.closeBracket) {
-                        return pos++, token = SyntaxKind.CloseBracketToken;
+                        return pos += 1, token = SyntaxKind.CloseBracketToken;
                     }
                     else if (ch === CharacterCodes.equals) {
-                        return pos++, token = SyntaxKind.EqualsToken;
+                        return pos += 1, token = SyntaxKind.EqualsToken;
                     }
                     else if (ch === CharacterCodes.comma) {
-                        return pos++, token = SyntaxKind.CommaToken;
+                        return pos += 1, token = SyntaxKind.CommaToken;
                     }
                     else if (isWhiteSpace(ch)) {
                         // Keep going
@@ -1714,7 +1714,7 @@ namespace ts {
                         identifierStarted = true;
                     }
                 }
-                pos++;
+                pos += 1;
             }
             return token = SyntaxKind.EndOfFileToken;
         }

src/harness/fourslash.ts

@@ -578,7 +578,7 @@ namespace FourSlash {
 
             const entries = this.getCompletionListAtCaret().entries;
             assert.isTrue(items.length <= entries.length, `Amount of expected items in completion list [ ${items.length} ] is greater than actual number of items in list [ ${entries.length} ]`);
-            for (let i = 0; i < items.length; ++i) {
+            for (let i = 0; i < items.length; i++) {
                 assert.equal(entries[i].name, items[i], `Unexpected item in completion list`);
             }
         }

src/server/server.ts

@@ -21,7 +21,6 @@ namespace ts.server {
     let writeHost = (data: string) => process.stdout.write(data);
 
     // Stubs for I/O
-    const onWrite = (output: string) => writeHost(output);
     const onInput = (input: string) => { return; };
     const onClose = () => { return; };
 

tests/cases/unittests/jsDocParsing.ts

@@ -1,4 +1,5 @@
 /// <reference path="..\..\..\src\harness\external\mocha.d.ts" />
+/// <reference path="..\..\..\src\harness\external\chai.d.ts" />
 /// <reference path="..\..\..\src\compiler\parser.ts" />
 /// <reference path="..\..\..\src\harness\harness.ts" />
 
@@ -1002,7 +1003,7 @@ module ts {
                     // Turn on a human-readable diff
                     if (typeof require !== 'undefined') {
                         require('chai').config.showDiff = true;
-                        expect(JSON.parse(result)).equal(JSON.parse(expected));
+                        chai.expect(JSON.parse(result)).equal(JSON.parse(expected));
                     }
                     else {
                         assert.equal(result, expected);