Merge branch 'testPerf2' into testPerf

Conflicts:	src/compiler/program.ts	src/compiler/types.ts	src/harness/harness.ts

Author: DanielRosenwasser

scripts/processDiagnosticMessages.ts

@@ -55,7 +55,7 @@ function buildInfoFileOutput(messageTable: InputDiagnosticMessageTable, nameMap:
  '// <auto-generated />\r\n' +
  '/// <reference path="types.ts" />\r\n' +
  '/* @internal */\r\n' +
- 'module ts {\r\n' +
+ 'namespace ts {\r\n' +
  ' export var Diagnostics = {\r\n';
  var names = Utilities.getObjectKeys(messageTable);
  for (var i = 0; i < names.length; i++) {

src/compiler/binder.ts

@@ -1,7 +1,7 @@
 /// <reference path="parser.ts"/>
 
 /* @internal */
-module ts {
+namespace ts {
  export let bindTime = 0;
 
  export const enum ModuleInstanceState {
@@ -90,10 +90,12 @@ module ts {
  let lastContainer: Node;
  let symbolCount = 0;
  let Symbol = objectAllocator.getSymbolConstructor();
+ let classifiableNames: Map<string> = {}; 
 
  if (!file.locals) {
  bind(file);
  file.symbolCount = symbolCount;
+ file.classifiableNames = classifiableNames;
  }
 
  return;
@@ -194,6 +196,11 @@ module ts {
  symbol = hasProperty(symbolTable, name)
  ? symbolTable[name]
  : (symbolTable[name] = createSymbol(SymbolFlags.None, name));
+ 
+ if (name && (includes & SymbolFlags.Classifiable)) {
+ classifiableNames[name] = name; 
+ } 
+
  if (symbol.flags & excludes) {
  if (node.name) {
  node.name.parent = node;
@@ -661,7 +668,11 @@ module ts {
  }
 
  function bindExportAssignment(node: ExportAssignment) {
- if (node.expression.kind === SyntaxKind.Identifier) {
+ if (!container.symbol || !container.symbol.exports) {
+ // Export assignment in some sort of block construct
+ bindAnonymousDeclaration(node, SymbolFlags.Alias, getDeclarationName(node));
+ }
+ else if (node.expression.kind === SyntaxKind.Identifier) {
  // An export default clause with an identifier exports all meanings of that identifier
  declareSymbol(container.symbol.exports, container.symbol, node, SymbolFlags.Alias, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
  }
@@ -672,7 +683,11 @@ module ts {
  }
 
  function bindExportDeclaration(node: ExportDeclaration) {
- if (!node.exportClause) {
+ if (!container.symbol || !container.symbol.exports) {
+ // Export * in some sort of block construct
+ bindAnonymousDeclaration(node, SymbolFlags.ExportStar, getDeclarationName(node));
+ }
+ else if (!node.exportClause) {
  // All export * declarations are collected in an __export symbol
  declareSymbol(container.symbol.exports, container.symbol, node, SymbolFlags.ExportStar, SymbolFlags.None);
  }

src/compiler/checker.ts

@@ -1,7 +1,7 @@
 /// <reference path="binder.ts"/>
 
 /* @internal */
-module ts {
+namespace ts {
  let nextSymbolId = 1;
  let nextNodeId = 1;
  let nextMergeId = 1;
@@ -4439,8 +4439,8 @@ module ts {
  maybeStack[depth][id] = RelationComparisonResult.Succeeded;
  depth++;
  let saveExpandingFlags = expandingFlags;
- if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack)) expandingFlags |= 1;
- if (!(expandingFlags & 2) && isDeeplyNestedGeneric(target, targetStack)) expandingFlags |= 2;
+ if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack, depth)) expandingFlags |= 1;
+ if (!(expandingFlags & 2) && isDeeplyNestedGeneric(target, targetStack, depth)) expandingFlags |= 2;
  let result: Ternary;
  if (expandingFlags === 3) {
  result = Ternary.Maybe;
@@ -4476,27 +4476,6 @@ module ts {
  return result;
  }
 
- // Return true if the given type is part of a deeply nested chain of generic instantiations. We consider this to be the case
- // when structural type comparisons have been started for 10 or more instantiations of the same generic type. It is possible,
- // though highly unlikely, for this test to be true in a situation where a chain of instantiations is not infinitely expanding.
- // Effectively, we will generate a false positive when two types are structurally equal to at least 10 levels, but unequal at
- // some level beyond that.
- function isDeeplyNestedGeneric(type: ObjectType, stack: ObjectType[]): boolean {
- // We track type references (created by createTypeReference) and instantiated types (created by instantiateType)
- if (type.flags & (TypeFlags.Reference | TypeFlags.Instantiated) && depth >= 10) {
- let symbol = type.symbol;
- let count = 0;
- for (let i = 0; i < depth; i++) {
- let t = stack[i];
- if (t.flags & (TypeFlags.Reference | TypeFlags.Instantiated) && t.symbol === symbol) {
- count++;
- if (count >= 10) return true;
- }
- }
- }
- return false;
- }
-
  function propertiesRelatedTo(source: ObjectType, target: ObjectType, reportErrors: boolean): Ternary {
  if (relation === identityRelation) {
  return propertiesIdenticalTo(source, target);
@@ -4815,6 +4794,27 @@ module ts {
  }
  }
 
+ // Return true if the given type is part of a deeply nested chain of generic instantiations. We consider this to be the case
+ // when structural type comparisons have been started for 10 or more instantiations of the same generic type. It is possible,
+ // though highly unlikely, for this test to be true in a situation where a chain of instantiations is not infinitely expanding.
+ // Effectively, we will generate a false positive when two types are structurally equal to at least 10 levels, but unequal at
+ // some level beyond that.
+ function isDeeplyNestedGeneric(type: Type, stack: Type[], depth: number): boolean {
+ // We track type references (created by createTypeReference) and instantiated types (created by instantiateType)
+ if (type.flags & (TypeFlags.Reference | TypeFlags.Instantiated) && depth >= 5) {
+ let symbol = type.symbol;
+ let count = 0;
+ for (let i = 0; i < depth; i++) {
+ let t = stack[i];
+ if (t.flags & (TypeFlags.Reference | TypeFlags.Instantiated) && t.symbol === symbol) {
+ count++;
+ if (count >= 5) return true;
+ }
+ }
+ }
+ return false;
+ }
+
  function isPropertyIdenticalTo(sourceProp: Symbol, targetProp: Symbol): boolean {
  return compareProperties(sourceProp, targetProp, compareTypes) !== Ternary.False;
  }
@@ -5129,21 +5129,6 @@ module ts {
  return false;
  }
 
- function isWithinDepthLimit(type: Type, stack: Type[]) {
- if (depth >= 5) {
- let target = (<TypeReference>type).target;
- let count = 0;
- for (let i = 0; i < depth; i++) {
- let t = stack[i];
- if (t.flags & TypeFlags.Reference && (<TypeReference>t).target === target) {
- count++;
- }
- }
- return count < 5;
- }
- return true;
- }
-
  function inferFromTypes(source: Type, target: Type) {
  if (source === anyFunctionType) {
  return;
@@ -5211,22 +5196,27 @@ module ts {
  else if (source.flags & TypeFlags.ObjectType && (target.flags & (TypeFlags.Reference | TypeFlags.Tuple) ||
  (target.flags & TypeFlags.Anonymous) && target.symbol && target.symbol.flags & (SymbolFlags.Method | SymbolFlags.TypeLiteral))) {
  // If source is an object type, and target is a type reference, a tuple type, the type of a method, or a type literal, infer from members
- if (!isInProcess(source, target) && isWithinDepthLimit(source, sourceStack) && isWithinDepthLimit(target, targetStack)) {
- if (depth === 0) {
- sourceStack = [];
- targetStack = [];
- }
- sourceStack[depth] = source;
- targetStack[depth] = target;
- depth++;
- inferFromProperties(source, target);
- inferFromSignatures(source, target, SignatureKind.Call);
- inferFromSignatures(source, target, SignatureKind.Construct);
- inferFromIndexTypes(source, target, IndexKind.String, IndexKind.String);
- inferFromIndexTypes(source, target, IndexKind.Number, IndexKind.Number);
- inferFromIndexTypes(source, target, IndexKind.String, IndexKind.Number);
- depth--;
+ if (isInProcess(source, target)) {
+ return;
+ }
+ if (isDeeplyNestedGeneric(source, sourceStack, depth) && isDeeplyNestedGeneric(target, targetStack, depth)) {
+ return;
  }
+
+ if (depth === 0) {
+ sourceStack = [];
+ targetStack = [];
+ }
+ sourceStack[depth] = source;
+ targetStack[depth] = target;
+ depth++;
+ inferFromProperties(source, target);
+ inferFromSignatures(source, target, SignatureKind.Call);
+ inferFromSignatures(source, target, SignatureKind.Construct);
+ inferFromIndexTypes(source, target, IndexKind.String, IndexKind.String);
+ inferFromIndexTypes(source, target, IndexKind.Number, IndexKind.Number);
+ inferFromIndexTypes(source, target, IndexKind.String, IndexKind.Number);
+ depth--;
  }
  }
 
@@ -7275,8 +7265,8 @@ module ts {
  checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, /*excludeArgument*/ undefined, /*reportErrors*/ true);
  }
  else if (candidateForTypeArgumentError) {
- if (!isTaggedTemplate && (<CallExpression>node).typeArguments) {
- checkTypeArguments(candidateForTypeArgumentError, (<CallExpression>node).typeArguments, [], /*reportErrors*/ true)
+ if (!isTaggedTemplate && typeArguments) {
+ checkTypeArguments(candidateForTypeArgumentError, typeArguments, [], /*reportErrors*/ true)
  }
  else {
  Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0);
@@ -11114,6 +11104,15 @@ module ts {
  function checkModuleDeclaration(node: ModuleDeclaration) {
  if (produceDiagnostics) {
  // Grammar checking
+ let isAmbientExternalModule = node.name.kind === SyntaxKind.StringLiteral;
+ let contextErrorMessage = isAmbientExternalModule
+ ? Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file
+ : Diagnostics.A_namespace_declaration_is_only_allowed_in_a_namespace_or_module;
+ if (checkGrammarModuleElementContext(node, contextErrorMessage)) {
+ // If we hit a module declaration in an illegal context, just bail out to avoid cascading errors.
+ return;
+ }
+
  if (!checkGrammarDeclarationNameInStrictMode(node) && !checkGrammarDecorators(node) && !checkGrammarModifiers(node)) {
  if (!isInAmbientContext(node) && node.name.kind === SyntaxKind.StringLiteral) {
  grammarErrorOnNode(node.name, Diagnostics.Only_ambient_modules_can_use_quoted_names);
@@ -11150,7 +11149,7 @@ module ts {
  }
 
  // Checks for ambient external modules.
- if (node.name.kind === SyntaxKind.StringLiteral) {
+ if (isAmbientExternalModule) {
  if (!isGlobalSourceFile(node.parent)) {
  error(node.name, Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules);
  }
@@ -11226,6 +11225,10 @@ module ts {
  }
 
  function checkImportDeclaration(node: ImportDeclaration) {
+ if (checkGrammarModuleElementContext(node, Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
+ // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors.
+ return;
+ }
  if (!checkGrammarImportDeclarationNameInStrictMode(node) && !checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & NodeFlags.Modifier)) {
  grammarErrorOnFirstToken(node, Diagnostics.An_import_declaration_cannot_have_modifiers);
  }
@@ -11248,6 +11251,11 @@ module ts {
  }
 
  function checkImportEqualsDeclaration(node: ImportEqualsDeclaration) {
+ if (checkGrammarModuleElementContext(node, Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
+ // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors.
+ return;
+ }
+
  checkGrammarDeclarationNameInStrictMode(node) || checkGrammarDecorators(node) || checkGrammarModifiers(node);
  if (isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
  checkImportBinding(node);
@@ -11279,9 +11287,15 @@ module ts {
  }
 
  function checkExportDeclaration(node: ExportDeclaration) {
+ if (checkGrammarModuleElementContext(node, Diagnostics.An_export_declaration_can_only_be_used_in_a_module)) {
+ // If we hit an export in an illegal context, just bail out to avoid cascading errors.
+ return;
+ }
+
  if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & NodeFlags.Modifier)) {
  grammarErrorOnFirstToken(node, Diagnostics.An_export_declaration_cannot_have_modifiers);
  }
+
  if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) {
  if (node.exportClause) {
  // export { x, y }
@@ -11303,6 +11317,12 @@ module ts {
  }
  }
 
+ function checkGrammarModuleElementContext(node: Statement, errorMessage: DiagnosticMessage): boolean {
+ if (node.parent.kind !== SyntaxKind.SourceFile && node.parent.kind !== SyntaxKind.ModuleBlock && node.parent.kind !== SyntaxKind.ModuleDeclaration) {
+ return grammarErrorOnFirstToken(node, errorMessage);
+ }
+ }
+
  function checkExportSpecifier(node: ExportSpecifier) {
  checkAliasSymbol(node);
  if (!(<ExportDeclaration>node.parent.parent).moduleSpecifier) {
@@ -11311,6 +11331,11 @@ module ts {
  }
 
  function checkExportAssignment(node: ExportAssignment) {
+ if (checkGrammarModuleElementContext(node, Diagnostics.An_export_assignment_can_only_be_used_in_a_module)) {
+ // If we hit an export assignment in an illegal context, just bail out to avoid cascading errors.
+ return;
+ }
+
  let container = node.parent.kind === SyntaxKind.SourceFile ? <SourceFile>node.parent : <ModuleDeclaration>node.parent.parent;
  if (container.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>container).name.kind === SyntaxKind.Identifier) {
  error(node, Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace);
@@ -11326,7 +11351,8 @@ module ts {
  else {
  checkExpressionCached(node.expression);
  }
- checkExternalModuleExports(container);
+
+ checkExternalModuleExports(<SourceFile | ModuleDeclaration>container);
 
  if (node.isExportEquals && !isInAmbientContext(node)) {
  if (languageVersion >= ScriptTarget.ES6) {
@@ -11340,7 +11366,7 @@ module ts {
  }
  }
 
- function getModuleStatements(node: Declaration): ModuleElement[] {
+ function getModuleStatements(node: Declaration): Statement[] {
  if (node.kind === SyntaxKind.SourceFile) {
  return (<SourceFile>node).statements;
  }
@@ -11593,6 +11619,8 @@ module ts {
  function checkSourceFileWorker(node: SourceFile) {
  let links = getNodeLinks(node);
  if (!(links.flags & NodeCheckFlags.TypeChecked)) {
+ // Check whether the file has declared it is the default lib,
+ // and whether the user has specifically chosen to avoid checking it.
  if (node.isDefaultLib && compilerOptions.skipDefaultLibCheck) {
  return;
  }

src/compiler/commandLineParser.ts

@@ -3,7 +3,7 @@
 /// <reference path="core.ts"/>
 /// <reference path="scanner.ts"/>
 
-module ts {
+namespace ts {
  /* @internal */
  export var optionDeclarations: CommandLineOption[] = [
  {

src/compiler/core.ts

@@ -1,7 +1,7 @@
 /// <reference path="types.ts"/>
 
 /* @internal */
-module ts {
+namespace ts {
  // Ternary values are defined such that
  // x & y is False if either x or y is False.
  // x & y is Maybe if either x or y is Maybe, but neither x or y is False.

src/compiler/declarationEmitter.ts

@@ -1,7 +1,7 @@
 /// <reference path="checker.ts"/>
 
 /* @internal */
-module ts {
+namespace ts {
  interface ModuleElementDeclarationEmitInfo {
  node: Node;
  outputPos: number;