Merge branch 'master' of https://github.com/Microsoft/TypeScript into typedefForJsdoc

Author: zhengbli

Jakefile.js

@@ -680,9 +680,9 @@ function cleanTestDirs() {
 }
 
 // used to pass data from jake command line directly to run.js
-function writeTestConfigFile(tests, light, testConfigFile) {
- console.log('Running test(s): ' + tests);
- var testConfigContents = JSON.stringify({ test: [tests], light: light });
+function writeTestConfigFile(tests, light, taskConfigsFolder, workerCount, testConfigFile) {
+ var testConfigContents = JSON.stringify({ test: tests ? [tests] : undefined, light: light, workerCount: workerCount, taskConfigsFolder: taskConfigsFolder });
+ console.log('Running tests with config: ' + testConfigContents);
  fs.writeFileSync('test.config', testConfigContents);
 }
 
@@ -692,7 +692,7 @@ function deleteTemporaryProjectOutput() {
  }
 }
 
-function runConsoleTests(defaultReporter, defaultSubsets) {
+function runConsoleTests(defaultReporter, runInParallel) {
  cleanTestDirs();
  var debug = process.env.debug || process.env.d;
  tests = process.env.test || process.env.tests || process.env.t;
@@ -701,9 +701,22 @@ function runConsoleTests(defaultReporter, defaultSubsets) {
  if(fs.existsSync(testConfigFile)) {
  fs.unlinkSync(testConfigFile);
  }
+ var workerCount, taskConfigsFolder;
+ if (runInParallel) {
+ // generate name to store task configuration files
+ var prefix = os.tmpdir() + "/ts-tests";
+ var i = 1;
+ do {
+ taskConfigsFolder = prefix + i;
+ i++;
+ } while (fs.existsSync(taskConfigsFolder));
+ fs.mkdirSync(taskConfigsFolder);
+
+ workerCount = process.env.workerCount || os.cpus().length;
+ }
 
- if (tests || light) {
- writeTestConfigFile(tests, light, testConfigFile);
+ if (tests || light || taskConfigsFolder) {
+ writeTestConfigFile(tests, light, taskConfigsFolder, workerCount, testConfigFile);
  }
 
  if (tests && tests.toLocaleLowerCase() === "rwc") {
@@ -717,61 +730,93 @@ function runConsoleTests(defaultReporter, defaultSubsets) {
 
  // timeout normally isn't necessary but Travis-CI has been timing out on compiler baselines occasionally
  // default timeout is 2sec which really should be enough, but maybe we just need a small amount longer
- var subsetRegexes;
- if(defaultSubsets.length === 0) {
- subsetRegexes = [tests];
+ if(!runInParallel) {
+ tests = tests ? ' -g "' + tests + '"' : '';
+ var cmd = "mocha" + (debug ? " --debug-brk" : "") + " -R " + reporter + tests + colors + ' -t ' + testTimeout + ' ' + run;
+ console.log(cmd);
+ exec(cmd, function () {
+ runLinter();
+ finish();
+ }, function(e, status) {
+ finish(status);
+ });
+ 
  }
  else {
- var subsets = tests ? tests.split("|") : defaultSubsets;
- subsetRegexes = subsets.map(function (sub) { return "^" + sub + ".*$"; });
- subsetRegexes.push("^(?!" + subsets.join("|") + ").*$");
- }
- var counter = subsetRegexes.length;
- var errorStatus;
- subsetRegexes.forEach(function (subsetRegex, i) {
- tests = subsetRegex ? ' -g "' + subsetRegex + '"' : '';
- var cmd = "mocha" + (debug ? " --debug-brk" : "") + " -R " + reporter + tests + colors + ' -t ' + testTimeout + ' ' + run;
+ // run task to load all tests and partition them between workers 
+ var cmd = "mocha " + " -R min " + colors + run;
  console.log(cmd);
- function finish(status) {
- counter--;
- // save first error status
- if (status !== undefined && errorStatus === undefined) {
- errorStatus = status;
- }
-
- deleteTemporaryProjectOutput();
- if (counter !== 0 || errorStatus === undefined) {
- // run linter when last worker is finished
- if (lintFlag && counter === 0) {
- var lint = jake.Task['lint'];
- lint.addListener('complete', function () {
+ exec(cmd, function() {
+ // read all configuration files and spawn a worker for every config
+ var configFiles = fs.readdirSync(taskConfigsFolder);
+ var counter = configFiles.length;
+ var firstErrorStatus;
+ // schedule work for chunks
+ configFiles.forEach(function (f) {
+ var configPath = path.join(taskConfigsFolder, f);
+ var workerCmd = "mocha" + " -t " + testTimeout + " -R " + reporter + " " + colors + " " + run + " --config='" + configPath + "'";
+ console.log(workerCmd);
+ exec(workerCmd, finishWorker, finishWorker) 
+ });
+ 
+ function finishWorker(e, errorStatus) {
+ counter--;
+ if (firstErrorStatus === undefined && errorStatus !== undefined) {
+ firstErrorStatus = errorStatus;
+ }
+ if (counter !== 0) {
+ complete();
+ }
+ else {
+ // last worker clean everything and runs linter in case if there were no errors
+ deleteTemporaryProjectOutput();
+ jake.rmRf(taskConfigsFolder);
+ if (firstErrorStatus === undefined) {
+ runLinter();
  complete();
- });
- lint.invoke();
+ }
+ else {
+ failWithStatus(firstErrorStatus);
+ }
  }
- complete();
- }
- else {
- fail("Process exited with code " + status);
  }
+ });
+ }
+ 
+ function failWithStatus(status) {
+ fail("Process exited with code " + status);
+ }
+ 
+ function finish(errorStatus) {
+ deleteTemporaryProjectOutput();
+ if (errorStatus !== undefined) {
+ failWithStatus(errorStatus);
  }
- exec(cmd, function () {
- finish();
- }, function(e, status) {
- finish(status);
+ else {
+ complete();
+ }
+ }
+ function runLinter() {
+ if (!lintFlag) {
+ return;
+ }
+ var lint = jake.Task['lint'];
+ lint.addListener('complete', function () {
+ complete();
  });
- });
+ lint.invoke();
+ }
 }
 
 var testTimeout = 20000;
 desc("Runs all the tests in parallel using the built run.js file. Optional arguments are: t[ests]=category1|category2|... d[ebug]=true.");
 task("runtests-parallel", ["build-rules", "tests", builtLocalDirectory], function() {
- runConsoleTests('min', ['compiler', 'conformance', 'Projects', 'fourslash']);
+ runConsoleTests('min', /*runInParallel*/ true);
 }, {async: true});
 
 desc("Runs the tests using the built run.js file. Optional arguments are: t[ests]=regex r[eporter]=[list|spec|json|<more>] d[ebug]=true color[s]=false lint=true.");
 task("runtests", ["build-rules", "tests", builtLocalDirectory], function() {
- runConsoleTests('mocha-fivemat-progress-reporter', []);
+ runConsoleTests('mocha-fivemat-progress-reporter', /*runInParallel*/ false);
 }, {async: true});
 
 desc("Generates code coverage data via instanbul");

src/compiler/binder.ts

@@ -929,8 +929,8 @@ namespace ts {
  preSwitchCaseFlow = currentFlow;
  bind(node.caseBlock);
  addAntecedent(postSwitchLabel, currentFlow);
- const hasDefault = forEach(node.caseBlock.clauses, c => c.kind === SyntaxKind.DefaultClause);
- if (!hasDefault) {
+ const hasNonEmptyDefault = forEach(node.caseBlock.clauses, c => c.kind === SyntaxKind.DefaultClause && c.statements.length);
+ if (!hasNonEmptyDefault) {
  addAntecedent(postSwitchLabel, preSwitchCaseFlow);
  }
  currentBreakTarget = saveBreakTarget;

src/compiler/checker.ts

@@ -1180,11 +1180,7 @@ namespace ts {
  }
 
  // This function is only for imports with entity names
- function getSymbolOfPartOfRightHandSideOfImportEquals(entityName: EntityName, importDeclaration?: ImportEqualsDeclaration): Symbol {
- if (!importDeclaration) {
- importDeclaration = <ImportEqualsDeclaration>getAncestor(entityName, SyntaxKind.ImportEqualsDeclaration);
- Debug.assert(importDeclaration !== undefined);
- }
+ function getSymbolOfPartOfRightHandSideOfImportEquals(entityName: EntityName, importDeclaration: ImportEqualsDeclaration, dontResolveAlias?: boolean): Symbol {
  // There are three things we might try to look for. In the following examples,
  // the search term is enclosed in |...|:
  //
@@ -1196,13 +1192,13 @@ namespace ts {
  }
  // Check for case 1 and 3 in the above example
  if (entityName.kind === SyntaxKind.Identifier || entityName.parent.kind === SyntaxKind.QualifiedName) {
- return resolveEntityName(entityName, SymbolFlags.Namespace);
+ return resolveEntityName(entityName, SymbolFlags.Namespace, /*ignoreErrors*/ false, dontResolveAlias);
  }
  else {
  // Case 2 in above example
  // entityName.kind could be a QualifiedName or a Missing identifier
  Debug.assert(entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration);
- return resolveEntityName(entityName, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
+ return resolveEntityName(entityName, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace, /*ignoreErrors*/ false, dontResolveAlias);
  }
  }
 
@@ -1211,7 +1207,7 @@ namespace ts {
  }
 
  // Resolves a qualified name and any involved aliases
- function resolveEntityName(name: EntityName | Expression, meaning: SymbolFlags, ignoreErrors?: boolean): Symbol {
+ function resolveEntityName(name: EntityName | Expression, meaning: SymbolFlags, ignoreErrors?: boolean, dontResolveAlias?: boolean): Symbol {
  if (nodeIsMissing(name)) {
  return undefined;
  }
@@ -1245,7 +1241,7 @@ namespace ts {
  Debug.fail("Unknown entity name kind.");
  }
  Debug.assert((symbol.flags & SymbolFlags.Instantiated) === 0, "Should never get an instantiated symbol here.");
- return symbol.flags & meaning ? symbol : resolveAlias(symbol);
+ return (symbol.flags & meaning) || dontResolveAlias ? symbol : resolveAlias(symbol);
  }
 
  function resolveExternalModuleName(location: Node, moduleReferenceExpression: Expression): Symbol {
@@ -9970,9 +9966,9 @@ namespace ts {
  }
 
  const apparentType = getApparentType(getWidenedType(type));
- if (apparentType === unknownType) {
- // handle cases when type is Type parameter with invalid constraint
- return unknownType;
+ if (apparentType === unknownType || (type.flags & TypeFlags.TypeParameter && isTypeAny(apparentType))) {
+ // handle cases when type is Type parameter with invalid or any constraint
+ return apparentType;
  }
  const prop = getPropertyOfType(apparentType, right.text);
  if (!prop) {
@@ -11163,7 +11159,9 @@ namespace ts {
  // types are provided for the argument expressions, and the result is always of type Any.
  // We exclude union types because we may have a union of function types that happen to have
  // no common signatures.
- if (isTypeAny(funcType) || (!callSignatures.length && !constructSignatures.length && !(funcType.flags & TypeFlags.Union) && isTypeAssignableTo(funcType, globalFunctionType))) {
+ if (isTypeAny(funcType) ||
+ (isTypeAny(apparentType) && funcType.flags & TypeFlags.TypeParameter) ||
+ (!callSignatures.length && !constructSignatures.length && !(funcType.flags & TypeFlags.Union) && isTypeAssignableTo(funcType, globalFunctionType))) {
  // The unknownType indicates that an error already occurred (and was reported). No
  // need to report another error in this case.
  if (funcType !== unknownType && node.typeArguments) {
@@ -14543,6 +14541,12 @@ namespace ts {
  }
 
  function areDeclarationFlagsIdentical(left: Declaration, right: Declaration) {
+ if ((left.kind === SyntaxKind.Parameter && right.kind === SyntaxKind.VariableDeclaration) ||
+ (left.kind === SyntaxKind.VariableDeclaration && right.kind === SyntaxKind.Parameter)) {
+ // Differences in optionality between parameters and variables are allowed.
+ return true;
+ }
+
  if (hasQuestionToken(left) !== hasQuestionToken(right)) {
  return false;
  }
@@ -16810,7 +16814,9 @@ namespace ts {
  if (entityName.kind !== SyntaxKind.PropertyAccessExpression) {
  if (isInRightSideOfImportOrExportAssignment(<EntityName>entityName)) {
  // Since we already checked for ExportAssignment, this really could only be an Import
- return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>entityName);
+ const importEqualsDeclaration = <ImportEqualsDeclaration>getAncestor(entityName, SyntaxKind.ImportEqualsDeclaration);
+ Debug.assert(importEqualsDeclaration !== undefined);
+ return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>entityName, importEqualsDeclaration, /*dontResolveAlias*/ true);
  }
  }
 
@@ -16906,9 +16912,7 @@ namespace ts {
 
  if (node.kind === SyntaxKind.Identifier) {
  if (isInRightSideOfImportOrExportAssignment(<Identifier>node)) {
- return node.parent.kind === SyntaxKind.ExportAssignment
- ? getSymbolOfEntityNameOrPropertyAccessExpression(<Identifier>node)
- : getSymbolOfPartOfRightHandSideOfImportEquals(<Identifier>node);
+ return getSymbolOfEntityNameOrPropertyAccessExpression(<Identifier>node);
  }
  else if (node.parent.kind === SyntaxKind.BindingElement &&
  node.parent.parent.kind === SyntaxKind.ObjectBindingPattern &&

src/harness/compilerRunner.ts

@@ -12,7 +12,7 @@ const enum CompilerTestType {
 
 class CompilerBaselineRunner extends RunnerBase {
  private basePath = "tests/cases";
- private testSuiteName: string;
+ private testSuiteName: TestRunnerKind;
  private errors: boolean;
  private emit: boolean;
  private decl: boolean;
@@ -41,6 +41,14 @@ class CompilerBaselineRunner extends RunnerBase {
  this.basePath += "/" + this.testSuiteName;
  }
 
+ public kind() {
+ return this.testSuiteName;
+ }
+
+ public enumerateTestFiles() {
+ return this.enumerateFiles(this.basePath, /\.tsx?$/, { recursive: true });
+ }
+
  private makeUnitName(name: string, root: string) {
  return ts.isRootedDiskPath(name) ? name : ts.combinePaths(root, name);
  };
@@ -391,7 +399,7 @@ class CompilerBaselineRunner extends RunnerBase {
 
  // this will set up a series of describe/it blocks to run between the setup and cleanup phases
  if (this.tests.length === 0) {
- const testFiles = this.enumerateFiles(this.basePath, /\.tsx?$/, { recursive: true });
+ const testFiles = this.enumerateTestFiles();
  testFiles.forEach(fn => {
  fn = fn.replace(/\\/g, "/");
  this.checkTestCodeOutput(fn);