Merge branch 'master' into emitArrowFunctionES6

Author: Yui T

scripts/bisect-test.ts

@@ -0,0 +1,56 @@
+/// <reference path="..\src\harness\external\node.d.ts" />
+
+import cp = require('child_process');
+import fs = require('fs');
+
+// Slice off 'node bisect-test.js' from the commandline args
+var args = process.argv.slice(2);
+
+function tsc(tscArgs: string, onExit: (exitCode: number) => void) {
+    var tsc = cp.exec('node built/local/tsc.js ' + tscArgs,() => void 0);
+    tsc.on('close', tscExitCode => {
+        onExit(tscExitCode);
+    });
+}
+
+var jake = cp.exec('jake clean local', () => void 0);
+jake.on('close', jakeExitCode => {
+    if (jakeExitCode === 0) {
+        // See what we're being asked to do
+        if (args[1] === 'compiles' || args[1] === '!compiles') {
+            tsc(args[0], tscExitCode => {
+                if ((tscExitCode === 0) === (args[1] === 'compiles')) {
+                    console.log('Good');
+                    process.exit(0); // Good
+                } else {
+                    console.log('Bad');
+                    process.exit(1); // Bad
+                }
+            });
+        } else if (args[1] === 'emits' || args[1] === '!emits') {
+            tsc(args[0], tscExitCode => {
+                fs.readFile(args[2], 'utf-8', (err, data) => {
+                    var doesContains = data.indexOf(args[3]) >= 0;
+                    if (doesContains === (args[1] === 'emits')) {
+                        console.log('Good');
+                        process.exit(0); // Good
+                    } else {
+                        console.log('Bad');
+                        process.exit(1); // Bad
+                    }
+                });
+            });
+        } else {
+            console.log('Unknown command line arguments.');
+            console.log('Usage (compile errors): git bisect run scripts\bisect.js "foo.ts --module amd" compiles');
+            console.log('Usage (emit check): git bisect run scripts\bisect.js bar.ts emits bar.js "_this = this"');
+            // Aborts the 'git bisect run' process
+            process.exit(-1);
+        }
+    } else {
+        // Compiler build failed; skip this commit
+        console.log('Skip');
+        process.exit(125); // bisect skip
+    }
+});
+ 

scripts/bisect.cmd

@@ -0,0 +1,30 @@
+echo off
+IF NOT EXIST scripts\bisect.cmd GOTO :wrongdir
+IF "%1" == "" GOTO :usage
+IF "%1" == "GO" GOTO :run
+GOTO :copy
+
+:usage
+echo Usage: bisect GoodCommit BadCommit test.ts compiles
+echo Usage: bisect GoodCommit BadCommit test.ts emits test.js "var x = 3"
+GOTO :eof
+
+:copy
+copy scripts\bisect.cmd scripts\bisect-fresh.cmd
+scripts\bisect-fresh GO %*
+GOTO :eof
+
+:run 
+call jake local
+node built/local/tsc.js scripts/bisect-test.ts --module commonjs
+git bisect start %2 %3
+git bisect run node scripts/bisect-test.js %4 %5 %6 %7
+del scripts\bisect-test.js
+del scripts\bisect-fresh.cmd
+GOTO :eof
+
+:wrongdir
+@echo Run this file from the repo folder, not the scripts folder
+GOTO :eof
+
+:eof

src/compiler/binder.ts

@@ -9,8 +9,8 @@ module ts {
 
     export function getModuleInstanceState(node: Node): ModuleInstanceState {
         // A module is uninstantiated if it contains only 
-        // 1. interface declarations
-        if (node.kind === SyntaxKind.InterfaceDeclaration) {
+        // 1. interface declarations, type alias declarations
+        if (node.kind === SyntaxKind.InterfaceDeclaration || node.kind === SyntaxKind.TypeAliasDeclaration) {
             return ModuleInstanceState.NonInstantiated;
         }
         // 2. const enum declarations don't make module instantiated
@@ -50,12 +50,13 @@ module ts {
     }
 
     /**
-     * Returns false if any of the following are true:
-     *   1. declaration has no name
-     *   2. declaration has a literal name (not computed)
-     *   3. declaration has a computed property name that is a known symbol
+     * A declaration has a dynamic name if both of the following are true:
+     *   1. The declaration has a computed property name
+     *   2. The computed name is *not* expressed as Symbol.<name>, where name
+     *      is a property of the Symbol constructor that denotes a built in
+     *      Symbol.
      */
-    export function hasComputedNameButNotSymbol(declaration: Declaration): boolean {
+    export function hasDynamicName(declaration: Declaration): boolean {
         return declaration.name && declaration.name.kind === SyntaxKind.ComputedPropertyName;
     }
 
@@ -96,7 +97,7 @@ module ts {
                 if (node.kind === SyntaxKind.ModuleDeclaration && node.name.kind === SyntaxKind.StringLiteral) {
                     return '"' + (<LiteralExpression>node.name).text + '"';
                 }
-                Debug.assert(!hasComputedNameButNotSymbol(node));
+                Debug.assert(!hasDynamicName(node));
                 return (<Identifier | LiteralExpression>node.name).text;
             }
             switch (node.kind) {
@@ -118,11 +119,7 @@ module ts {
         }
 
         function declareSymbol(symbols: SymbolTable, parent: Symbol, node: Declaration, includes: SymbolFlags, excludes: SymbolFlags): Symbol {
-            // Nodes with computed property names will not get symbols, because the type checker
-            // does not make properties for them.
-            if (hasComputedNameButNotSymbol(node)) {
-                return undefined;
-            }
+            Debug.assert(!hasDynamicName(node));
 
             var name = getDeclarationName(node);
             if (name !== undefined) {
@@ -395,14 +392,14 @@ module ts {
                     break;
                 case SyntaxKind.PropertyDeclaration:
                 case SyntaxKind.PropertySignature:
-                    bindDeclaration(<Declaration>node, SymbolFlags.Property | ((<PropertyDeclaration>node).questionToken ? SymbolFlags.Optional : 0), SymbolFlags.PropertyExcludes, /*isBlockScopeContainer*/ false);
+                    bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.Property | ((<PropertyDeclaration>node).questionToken ? SymbolFlags.Optional : 0), SymbolFlags.PropertyExcludes, /*isBlockScopeContainer*/ false);
                     break;
                 case SyntaxKind.PropertyAssignment:
                 case SyntaxKind.ShorthandPropertyAssignment:
-                    bindDeclaration(<Declaration>node, SymbolFlags.Property, SymbolFlags.PropertyExcludes, /*isBlockScopeContainer*/ false);
+                    bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.Property, SymbolFlags.PropertyExcludes, /*isBlockScopeContainer*/ false);
                     break;
                 case SyntaxKind.EnumMember:
-                    bindDeclaration(<Declaration>node, SymbolFlags.EnumMember, SymbolFlags.EnumMemberExcludes, /*isBlockScopeContainer*/ false);
+                    bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.EnumMember, SymbolFlags.EnumMemberExcludes, /*isBlockScopeContainer*/ false);
                     break;
                 case SyntaxKind.CallSignature:
                 case SyntaxKind.ConstructSignature:
@@ -415,7 +412,7 @@ module ts {
                     // as other properties in the object literal.  So we use SymbolFlags.PropertyExcludes
                     // so that it will conflict with any other object literal members with the same
                     // name.
-                    bindDeclaration(<Declaration>node, SymbolFlags.Method | ((<MethodDeclaration>node).questionToken ? SymbolFlags.Optional : 0),
+                    bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.Method | ((<MethodDeclaration>node).questionToken ? SymbolFlags.Optional : 0),
                         isObjectLiteralMethod(node) ? SymbolFlags.PropertyExcludes : SymbolFlags.MethodExcludes, /*isBlockScopeContainer*/ true);
                     break;
                 case SyntaxKind.FunctionDeclaration:
@@ -425,10 +422,10 @@ module ts {
                     bindDeclaration(<Declaration>node, SymbolFlags.Constructor, /*symbolExcludes:*/ 0, /*isBlockScopeContainer:*/ true);
                     break;
                 case SyntaxKind.GetAccessor:
-                    bindDeclaration(<Declaration>node, SymbolFlags.GetAccessor, SymbolFlags.GetAccessorExcludes, /*isBlockScopeContainer*/ true);
+                    bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.GetAccessor, SymbolFlags.GetAccessorExcludes, /*isBlockScopeContainer*/ true);
                     break;
                 case SyntaxKind.SetAccessor:
-                    bindDeclaration(<Declaration>node, SymbolFlags.SetAccessor, SymbolFlags.SetAccessorExcludes, /*isBlockScopeContainer*/ true);
+                    bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.SetAccessor, SymbolFlags.SetAccessorExcludes, /*isBlockScopeContainer*/ true);
                     break;
 
                 case SyntaxKind.FunctionType:
@@ -510,5 +507,14 @@ module ts {
                 declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes);
             }
         }
+
+        function bindPropertyOrMethodOrAccessor(node: Declaration, symbolKind: SymbolFlags, symbolExcludes: SymbolFlags, isBlockScopeContainer: boolean) {
+            if (hasDynamicName(node)) {
+                bindAnonymousDeclaration(node, symbolKind, "__computed", isBlockScopeContainer);
+            }
+            else {
+                bindDeclaration(node, symbolKind, symbolExcludes, isBlockScopeContainer);
+            }
+        }
     }
 }