Merge branch 'master' into getReferences

Conflicts:
	tests/baselines/reference/aliasUsageInGenericFunction.types
	tests/baselines/reference/aliasUsageInObjectLiteral.types
	tests/baselines/reference/aliasUsageInOrExpression.types
	tests/baselines/reference/extendingClassFromAliasAndUsageInIndexer.types

Author: mhegazy

Jakefile

@@ -43,7 +43,6 @@ var compilerSources = [
 
 var servicesSources = [
     "core.ts",
-    "sys.ts",
     "types.ts",
     "scanner.ts",
     "parser.ts",

bin/services.js

@@ -908,7 +908,7 @@ module ts {
             // Get qualified name 
             if (enclosingDeclaration &&
                 // Properties/methods/Signatures/Constructors/TypeParameters do not need qualification
-                !(symbol.flags & SymbolFlags.PropertyOrAccessor & SymbolFlags.Signature & SymbolFlags.Constructor & SymbolFlags.Method & SymbolFlags.TypeParameter)) {
+                !(symbol.flags & (SymbolFlags.PropertyOrAccessor | SymbolFlags.Signature | SymbolFlags.Constructor | SymbolFlags.Method | SymbolFlags.TypeParameter))) {
                 var symbolName: string;
                 while (symbol) {
                     var isFirstName = !symbolName;
@@ -2238,13 +2238,12 @@ module ts {
                 return emptyObjectType;
             }
             var type = getDeclaredTypeOfSymbol(symbol);
-            var name = symbol.name;
             if (!(type.flags & TypeFlags.ObjectType)) {
-                error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_be_a_class_or_interface_type, name);
+                error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_be_a_class_or_interface_type, symbol.name);
                 return emptyObjectType;
             }
             if (((<InterfaceType>type).typeParameters ? (<InterfaceType>type).typeParameters.length : 0) !== arity) {
-                error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_have_1_type_parameter_s, name, arity);
+                error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_have_1_type_parameter_s, symbol.name, arity);
                 return emptyObjectType;
             }
             return <ObjectType>type;
@@ -3548,7 +3547,8 @@ module ts {
             return false;
         }
 
-        function checkSuperExpression(node: Node, isCallExpression: boolean): Type {
+        function checkSuperExpression(node: Node): Type {
+            var isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).func === node;
             var enclosingClass = <ClassDeclaration>getAncestor(node, SyntaxKind.ClassDeclaration);
             var baseClass: Type;
             if (enclosingClass && enclosingClass.baseType) {
@@ -4183,7 +4183,7 @@ module ts {
 
         function resolveCallExpression(node: CallExpression): Signature {
             if (node.func.kind === SyntaxKind.SuperKeyword) {
-                var superType = checkSuperExpression(node.func, true);
+                var superType = checkSuperExpression(node.func);
                 if (superType !== unknownType) {
                     return resolveCall(node, getSignaturesOfType(superType, SignatureKind.Construct));
                 }
@@ -4831,7 +4831,7 @@ module ts {
                 case SyntaxKind.ThisKeyword:
                     return checkThisExpression(node);
                 case SyntaxKind.SuperKeyword:
-                    return checkSuperExpression(node, false);
+                    return checkSuperExpression(node);
                 case SyntaxKind.NullKeyword:
                     return nullType;
                 case SyntaxKind.TrueKeyword:
@@ -6775,6 +6775,11 @@ module ts {
                     /*all meanings*/ SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Import);
             }
 
+            if (isInRightSideOfImportOrExportAssignment(entityName)) {
+                // Since we already checked for ExportAssignment, this really could only be an Import
+                return getSymbolOfPartOfRightHandSideOfImport(entityName);
+            }
+
             if (isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
                 entityName = entityName.parent;
             }
@@ -6895,11 +6900,7 @@ module ts {
             }
 
             if (isInRightSideOfImportOrExportAssignment(node)) {
-                var symbol: Symbol;
-                symbol = node.parent.kind === SyntaxKind.ExportAssignment
-                    ? getSymbolInfo(node)
-                    : getSymbolOfPartOfRightHandSideOfImport(node);
-
+                var symbol = getSymbolInfo(node);
                 var declaredType = getDeclaredTypeOfSymbol(symbol);
                 return declaredType !== unknownType ? declaredType : getTypeOfSymbol(symbol);
             }
@@ -7073,7 +7074,20 @@ module ts {
         function isImplementationOfOverload(node: FunctionDeclaration) {
             if (node.body) {
                 var symbol = getSymbolOfNode(node);
-                return getSignaturesOfSymbol(symbol).length > 1;
+                var signaturesOfSymbol = getSignaturesOfSymbol(symbol);
+                // If this function body corresponds to function with multiple signature, it is implementation of overload
+                // eg: function foo(a: string): string;
+                //     function foo(a: number): number;
+                //     function foo(a: any) { // This is implementation of the overloads
+                //         return a;
+                //     }
+                return signaturesOfSymbol.length > 1 ||
+                    // If there is single signature for the symbol, it is overload if that signature isnt coming from the node
+                    // eg: function foo(a: string): string;
+                    //     function foo(a: any) { // This is implementation of the overloads
+                    //         return a;
+                    //     }
+                    (signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node);
             }
             return false;
         }

bin/tsc.js

@@ -509,12 +509,6 @@ module ts {
         return pathLen > extLen && path.substr(pathLen - extLen, extLen) === extension;
     }
 
-    export function getCanonicalFileName(fileName: string): string {
-        // if underlying system can distinguish between two files whose names differs only in cases then file name already in canonical form.
-        // otherwise use toLowerCase as a canonical form.
-        return sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
-    }
-
     export interface ObjectAllocator {
         getNodeConstructor(kind: SyntaxKind): new () => Node;
         getSymbolConstructor(): new (flags: SymbolFlags, name: string) => Symbol;

bin/typescriptServices.js

@@ -290,7 +290,7 @@ module ts {
                 }
                 else {
                     // Empty string - make sure we write empty line
-                    writer.writeLiteral(sys.newLine);
+                    writer.writeLiteral(newLine);
                 }
             }
 
@@ -336,6 +336,9 @@ module ts {
             /** Emit detached comments of the node */
             var emitDetachedComments = compilerOptions.removeComments ? (node: TextRange) => { } : emitDetachedCommentsAtPosition;
 
+            /** Emits /// or pinned which is comment starting with /*! comments */
+            var emitPinnedOrTripleSlashComments = compilerOptions.removeComments ? (node: Node) => { } : emitPinnedOrTripleSlashCommentsOfNode;
+
             var writeComment = writeCommentRange;
 
             /** Emit a node */
@@ -1318,7 +1321,10 @@ module ts {
             }
 
             function emitFunctionDeclaration(node: FunctionDeclaration) {
-                if (!node.body) return;
+                if (!node.body) {
+                    return emitPinnedOrTripleSlashComments(node);
+                }
+
                 if (node.kind !== SyntaxKind.Method) {
                     // Methods will emit the comments as part of emitting method declaration
                     emitLeadingComments(node);
@@ -1488,7 +1494,10 @@ module ts {
             function emitMemberFunctions(node: ClassDeclaration) {
                 forEach(node.members, member => {
                     if (member.kind === SyntaxKind.Method) {
-                        if (!(<MethodDeclaration>member).body) return;
+                        if (!(<MethodDeclaration>member).body) {
+                            return emitPinnedOrTripleSlashComments(member);
+                        }
+
                         writeLine();
                         emitLeadingComments(member);
                         emitStart(member);
@@ -1611,6 +1620,13 @@ module ts {
                 emitTrailingComments(node);
 
                 function emitConstructorOfClass() {
+                    // Emit the constructor overload pinned comments
+                    forEach(node.members, member => {
+                        if (member.kind === SyntaxKind.Constructor && !(<ConstructorDeclaration>member).body) {
+                            emitPinnedOrTripleSlashComments(member);
+                        }
+                    });
+
                     var ctor = getFirstConstructorWithBody(node);
                     if (ctor) {
                         emitLeadingComments(ctor);
@@ -1666,6 +1682,10 @@ module ts {
                 }
             }
 
+            function emitInterfaceDeclaration(node: InterfaceDeclaration) {
+                emitPinnedOrTripleSlashComments(node);
+            }
+
             function emitEnumDeclaration(node: EnumDeclaration) {
                 emitLeadingComments(node);
                 if (!(node.flags & NodeFlags.Export)) {
@@ -1741,7 +1761,10 @@ module ts {
             }
 
             function emitModuleDeclaration(node: ModuleDeclaration) {
-                if (!isInstantiated(node)) return;
+                if (!isInstantiated(node)) {
+                    return emitPinnedOrTripleSlashComments(node);
+                }
+
                 emitLeadingComments(node);
                 if (!(node.flags & NodeFlags.Export)) {
                     emitStart(node);
@@ -1969,7 +1992,14 @@ module ts {
             }
 
             function emitNode(node: Node) {
-                if (!node || node.flags & NodeFlags.Ambient) return;
+                if (!node) {
+                    return;
+                }
+
+                if (node.flags & NodeFlags.Ambient) {
+                    return emitPinnedOrTripleSlashComments(node);
+                }
+
                 switch (node.kind) {
                     case SyntaxKind.Identifier:
                         return emitIdentifier(<Identifier>node);
@@ -2073,6 +2103,8 @@ module ts {
                         return emitVariableDeclaration(<VariableDeclaration>node);
                     case SyntaxKind.ClassDeclaration:
                         return emitClassDeclaration(<ClassDeclaration>node);
+                    case SyntaxKind.InterfaceDeclaration:
+                        return emitInterfaceDeclaration(<InterfaceDeclaration>node);
                     case SyntaxKind.EnumDeclaration:
                         return emitEnumDeclaration(<EnumDeclaration>node);
                     case SyntaxKind.ModuleDeclaration:
@@ -2101,7 +2133,7 @@ module ts {
                 return leadingComments;
             }
 
-            function emitLeadingDeclarationComments(node: Node) {
+            function getLeadingCommentsToEmit(node: Node) {
                 // Emit the leading comments only if the parent's pos doesnt match because parent should take care of emitting these comments
                 if (node.parent.kind === SyntaxKind.SourceFile || node.pos !== node.parent.pos) {
                     var leadingComments: Comment[];
@@ -2113,12 +2145,17 @@ module ts {
                         // get the leading comments from the node
                         leadingComments = getLeadingCommentsOfNode(node, currentSourceFile);
                     }
-                    emitNewLineBeforeLeadingComments(node, leadingComments, writer);
-                    // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
-                    emitComments(leadingComments, /*trailingSeparator*/ true, writer, writeComment);
+                    return leadingComments;
                 }
             }
 
+            function emitLeadingDeclarationComments(node: Node) {
+                var leadingComments = getLeadingCommentsToEmit(node);
+                emitNewLineBeforeLeadingComments(node, leadingComments, writer);
+                // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
+                emitComments(leadingComments, /*trailingSeparator*/ true, writer, writeComment);
+            }
+
             function emitTrailingDeclarationComments(node: Node) {
                 // Emit the trailing comments only if the parent's end doesnt match
                 if (node.parent.kind === SyntaxKind.SourceFile || node.end !== node.parent.end) {
@@ -2166,7 +2203,7 @@ module ts {
                         lastComment = comment;
                     });
 
-                    if (detachedComments && detachedComments.length) {
+                    if (detachedComments.length) {
                         // All comments look like they could have been part of the copyright header.  Make
                         // sure there is at least one blank line between it and the node.  If not, it's not
                         // a copyright header.
@@ -2188,6 +2225,28 @@ module ts {
                 }
             }
 
+            function emitPinnedOrTripleSlashCommentsOfNode(node: Node) {
+                var pinnedComments = ts.filter(getLeadingCommentsToEmit(node), isPinnedOrTripleSlashComment);
+
+                function isPinnedOrTripleSlashComment(comment: Comment) {
+                    if (currentSourceFile.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk) {
+                        return currentSourceFile.text.charCodeAt(comment.pos + 2) === CharacterCodes.exclamation;
+                    }
+                    // Verify this is /// comment, but do the regexp match only when we first can find /// in the comment text 
+                    // so that we dont end up computing comment string and doing match for all // comments
+                    else if (currentSourceFile.text.charCodeAt(comment.pos + 1) === CharacterCodes.slash &&
+                        comment.pos + 2 < comment.end &&
+                        currentSourceFile.text.charCodeAt(comment.pos + 2) === CharacterCodes.slash &&
+                        currentSourceFile.text.substring(comment.pos, comment.end).match(fullTripleSlashReferencePathRegEx)) {
+                        return true;
+                    }
+                }
+
+                emitNewLineBeforeLeadingComments(node, pinnedComments, writer);
+                // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
+                emitComments(pinnedComments, /*trailingSeparator*/ true, writer, writeComment);
+            }
+
             if (compilerOptions.sourceMap) {
                 initializeEmitterWithSourceMaps();
             }

src/compiler/checker.ts

@@ -1,4 +1,3 @@
-/// <reference path="sys.ts"/>
 /// <reference path="types.ts"/>
 /// <reference path="core.ts"/>
 /// <reference path="scanner.ts"/>
@@ -165,6 +164,8 @@ module ts {
         }
     }
 
+    export var fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*<reference\s+path\s*=\s*)('|")(.+?)\2.*?\/>/
+
     // Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes
     // stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,
     // embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns
@@ -3555,8 +3556,7 @@ module ts {
                         file.hasNoDefaultLib = true;
                     }
                     else {
-                        var fullReferenceRegEx = /^(\/\/\/\s*<reference\s+path\s*=\s*)('|")(.+?)\2.*?\/>/;
-                        var matchResult = fullReferenceRegEx.exec(comment);
+                        var matchResult = fullTripleSlashReferencePathRegEx.exec(comment);
                         if (!matchResult) {
                             var start = range.pos;
                             var length = range.end - start;

src/compiler/core.ts

@@ -137,6 +137,12 @@ module ts {
         var currentDirectory: string;
         var existingDirectories: Map<boolean> = {};
 
+        function getCanonicalFileName(fileName: string): string {
+            // if underlying system can distinguish between two files whose names differs only in cases then file name already in canonical form.
+            // otherwise use toLowerCase as a canonical form.
+            return sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
+        }
+
         function getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile {
             try {
                 var text = sys.readFile(filename, options.charset);
@@ -323,6 +329,7 @@ module ts {
     function compile(commandLine: ParsedCommandLine, compilerHost: CompilerHost) {
         var parseStart = new Date().getTime();
         var program = createProgram(commandLine.filenames, commandLine.options, compilerHost);
+
         var bindStart = new Date().getTime();
         var errors = program.getDiagnostics();
         if (errors.length) {