Merge branch 'master' into bom

Conflicts:
	src/compiler/commandLineParser.ts
	src/compiler/emitter.ts

Author: mhegazy

Jakefile

@@ -197,6 +197,8 @@ var processDiagnosticMessagesTs = path.join(scriptsDirectory, "processDiagnostic
 var diagnosticMessagesJson = path.join(compilerDirectory, "diagnosticMessages.json");
 var diagnosticInfoMapTs = path.join(compilerDirectory, "diagnosticInformationMap.generated.ts");
 
+file(processDiagnosticMessagesTs)
+
 // processDiagnosticMessages script
 compileFile(processDiagnosticMessagesJs,
             [processDiagnosticMessagesTs],

bin/lib.scripthost.d.ts renamed to bin/lib.scriptHost.d.ts

@@ -39,7 +39,7 @@ function main(): void {
 function buildUniqueNameMap(names: string[]): IIndexable<string> {
     var nameMap: IIndexable<string> = {};
 
-    var uniqueNames = NameGenerator.ensureUniqueness(names, /*isFixed */ undefined, /* isCaseSensitive */ false);
+    var uniqueNames = NameGenerator.ensureUniqueness(names, /* isCaseSensitive */ false, /* isFixed */ undefined);
 
     for (var i = 0; i < names.length; i++) {
         nameMap[names[i]] = uniqueNames[i];
@@ -94,17 +94,17 @@ function convertPropertyName(origName: string): string {
 }
 
 module NameGenerator {
-    export function ensureUniqueness(
-        names: string[],
-        isFixed: boolean[]= names.map(() => false),
-        isCaseSensitive: boolean = true): string[] {
+    export function ensureUniqueness(names: string[], isCaseSensitive: boolean, isFixed?: boolean[]): string[]{
+        if (!isFixed) {
+            isFixed = names.map(() => false)
+        }
 
-        var names = names.map(x => x);
-        ensureUniquenessInPlace(names, isFixed, isCaseSensitive);
+        var names = names.slice();
+        ensureUniquenessInPlace(names, isCaseSensitive, isFixed);
         return names;
     }
 
-    function ensureUniquenessInPlace(names: string[], isFixed: boolean[], isCaseSensitive: boolean): void {
+    function ensureUniquenessInPlace(names: string[], isCaseSensitive: boolean, isFixed: boolean[]): void {
         for (var i = 0; i < names.length; i++) {
             var name = names[i];
             var collisionIndices = Utilities.collectMatchingIndices(name, names, isCaseSensitive);
@@ -131,9 +131,12 @@ module NameGenerator {
             }
 
             while (true) {
-                var newName = name + suffix++;
+                var newName = name + suffix;
+                suffix++;
 
-                if (proposedNames.some((name) => Utilities.stringEquals(name, newName, isCaseSensitive))) {
+                // Check if we've synthesized a unique name, and if so
+                // replace the conflicting name with the new one.
+                if (!proposedNames.some(name => Utilities.stringEquals(name, newName, isCaseSensitive))) {
                     proposedNames[collisionIndex] = newName;
                     break;
                 }
@@ -144,7 +147,7 @@ module NameGenerator {
 
 module Utilities {
     /// Return a list of all indices where a string occurs.
-    export function collectMatchingIndices(name: string, proposedNames: string[], isCaseSensitive: boolean = true): number[] {
+    export function collectMatchingIndices(name: string, proposedNames: string[], isCaseSensitive: boolean): number[] {
         var matchingIndices: number[] = [];
 
         for (var i = 0; i < proposedNames.length; i++) {
@@ -156,8 +159,8 @@ module Utilities {
         return matchingIndices;
     }
 
-    export function stringEquals(s1: string, s2: string, caseSensitive: boolean = true): boolean {
-        if (!caseSensitive) {
+    export function stringEquals(s1: string, s2: string, caseSensitive: boolean): boolean {
+        if (caseSensitive) {
             s1 = s1.toLowerCase();
             s2 = s2.toLowerCase();
         }

scripts/processDiagnosticMessages.ts

@@ -677,7 +677,7 @@ module ts {
                 }
 
                 // If symbol is directly available by its name in the symbol table
-                if (isAccessible(symbols[symbol.name])) {
+                if (isAccessible(lookUp(symbols, symbol.name))) {
                     return symbol;
                 }
 
@@ -700,7 +700,7 @@ module ts {
             var qualify = false;
             forEachSymbolTableInScope(enclosingDeclaration, symbolTable => {
                 // If symbol of this name is not available in the symbol table we are ok
-                if (!symbolTable[symbol.name]) {
+                if (!hasProperty(symbolTable, symbol.name)) {
                     // Continue to the next symbol table
                     return false;
                 }
@@ -725,6 +725,52 @@ module ts {
             return qualify;
         }
 
+        function isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult {
+            if (symbol && enclosingDeclaration && !(symbol.flags & SymbolFlags.TypeParameter)) {
+                var initialSymbol = symbol;
+                var meaningToLook = meaning;
+                while (symbol) {
+                    // Symbol is accessible if it by itself is accessible
+                    var accessibleSymbol = getAccessibleSymbol(symbol, enclosingDeclaration, meaningToLook);
+                    if (accessibleSymbol) {
+                        if (forEach(accessibleSymbol.declarations, declaration => !isDeclarationVisible(declaration))) {
+                            return {
+                                accessibility: SymbolAccessibility.NotAccessible,
+                                errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
+                                errorModuleName: symbol !== initialSymbol ? symbolToString(symbol, enclosingDeclaration, SymbolFlags.Namespace) : undefined
+                            };
+                        }
+                        return { accessibility: SymbolAccessibility.Accessible };
+                    }
+
+                    // TODO(shkamat): Handle static method of class
+
+                    // If we havent got the accessible symbol doesnt mean the symbol is actually inaccessible. 
+                    // It could be qualified symbol and hence verify the path
+                    // eg:
+                    // module m {
+                    //     export class c {
+                    //     }
+                    // }
+                    // var x: typeof m.c
+                    // In the above example when we start with checking if typeof m.c symbol is accessible,
+                    // we are going to see if c can be accessed in scope directly. 
+                    // But it cant, hence the accessible is going to be undefined, but that doesnt mean m.c is accessible
+                    // It is accessible if the parent m is accessible because then m.c can be accessed through qualification
+                    meaningToLook = SymbolFlags.Namespace;
+                    symbol = symbol.parent;
+                }
+
+                // This is a local symbol that cannot be named
+                return {
+                    accessibility: SymbolAccessibility.CannotBeNamed,
+                    errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
+                };
+            }
+
+            return { accessibility: SymbolAccessibility.Accessible };
+        }
+
         // Enclosing declaration is optional when we dont want to get qualified name in the enclosing declaration scope
         // Meaning needs to be specified if the enclosing declaration is given
         function symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {
@@ -760,10 +806,15 @@ module ts {
             return getSymbolName(symbol);
         }
 
+        function writeSymbolToTextWriter(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags, writer: TextWriter) {
+            writer.write(symbolToString(symbol, enclosingDeclaration, meaning));
+        }
+
         function createSingleLineTextWriter() {
             var result = "";
             return {
                 write(s: string) { result += s; },
+                writeSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) { writeSymbolToTextWriter(symbol, enclosingDeclaration, meaning, this); },
                 writeLine() { result += " "; },
                 increaseIndent() { },
                 decreaseIndent() { },
@@ -790,7 +841,7 @@ module ts {
                     writeTypeReference(<TypeReference>type);
                 }
                 else if (type.flags & (TypeFlags.Class | TypeFlags.Interface | TypeFlags.Enum | TypeFlags.TypeParameter)) {
-                    writer.write(symbolToString(type.symbol, enclosingDeclaration, SymbolFlags.Type));
+                    writer.writeSymbol(type.symbol, enclosingDeclaration, SymbolFlags.Type);
                 }
                 else if (type.flags & TypeFlags.Anonymous) {
                     writeAnonymousType(<ObjectType>type, allowFunctionOrConstructorTypeLiteral);
@@ -812,7 +863,7 @@ module ts {
                     writer.write("[]");
                 }
                 else {
-                    writer.write(symbolToString(type.target.symbol, enclosingDeclaration, SymbolFlags.Type));
+                    writer.writeSymbol(type.target.symbol, enclosingDeclaration, SymbolFlags.Type);
                     writer.write("<");
                     for (var i = 0; i < type.typeArguments.length; i++) {
                         if (i > 0) {
@@ -846,7 +897,7 @@ module ts {
 
             function writeTypeofSymbol(type: ObjectType) {
                 writer.write("typeof ");
-                writer.write(symbolToString(type.symbol, enclosingDeclaration, SymbolFlags.Value));
+                writer.writeSymbol(type.symbol, enclosingDeclaration, SymbolFlags.Value);
             }
 
             function writeLiteralType(type: ObjectType, allowFunctionOrConstructorTypeLiteral: boolean) {
@@ -902,7 +953,7 @@ module ts {
                     if (p.flags & (SymbolFlags.Function | SymbolFlags.Method) && !getPropertiesOfType(t).length) {
                         var signatures = getSignaturesOfType(t, SignatureKind.Call);
                         for (var j = 0; j < signatures.length; j++) {
-                            writer.write(symbolToString(p));
+                            writer.writeSymbol(p);
                             if (isOptionalProperty(p)) {
                                 writer.write("?");
                             }
@@ -912,7 +963,7 @@ module ts {
                         }
                     }
                     else {
-                        writer.write(symbolToString(p));
+                        writer.writeSymbol(p);
                         if (isOptionalProperty(p)) {
                             writer.write("?");
                         }
@@ -934,7 +985,7 @@ module ts {
                             writer.write(", ");
                         }
                         var tp = signature.typeParameters[i];
-                        writer.write(symbolToString(tp.symbol));
+                        writer.writeSymbol(tp.symbol);
                         var constraint = getConstraintOfTypeParameter(tp);
                         if (constraint) {
                             writer.write(" extends ");
@@ -952,7 +1003,7 @@ module ts {
                     if (getDeclarationFlagsFromSymbol(p) & NodeFlags.Rest) {
                         writer.write("...");
                     }
-                    writer.write(symbolToString(p));
+                    writer.writeSymbol(p);
                     if (p.valueDeclaration.flags & NodeFlags.QuestionMark || (<VariableDeclaration>p.valueDeclaration).initializer) {
                         writer.write("?");
                     }
@@ -6695,7 +6746,9 @@ module ts {
                 isDeclarationVisible: isDeclarationVisible,
                 isImplementationOfOverload: isImplementationOfOverload,
                 writeTypeAtLocation: writeTypeAtLocation,
-                writeReturnTypeOfSignatureDeclaration: writeReturnTypeOfSignatureDeclaration
+                writeReturnTypeOfSignatureDeclaration: writeReturnTypeOfSignatureDeclaration,
+                writeSymbol: writeSymbolToTextWriter,
+                isSymbolAccessible: isSymbolAccessible
             };
             checkProgram();
             return emitFiles(resolver);