Merged Declarations for Classes and Interfaces

src/compiler/binder.ts

@@ -135,6 +135,26 @@ module ts {
  return node.name ? declarationNameToString(node.name) : getDeclarationName(node);
  }
 
+ /* internal */
+ /**
+ * Checks if the symbol contains a class declaration declaration that is non-ambient.
+ */
+ function hasNonAmbientClass(symbol: Symbol): boolean {
+ if (symbol) {
+ return !! forEach(symbol.declarations, (element: Declaration, index: number) => {
+ return (element.kind === SyntaxKind.ClassDeclaration && !(element.flags & NodeFlags.Ambient))
+ });
+ }
+ }
+
+ /**
+ * Declares a Symbol for the Node and add it to symbols. Reports errors for conflicting identifier names,
+ * @param symbols - The symbolTable which node will be added to.
+ * @param parent - If node is in a class, parent denotes the parent declaration.
+ * @param node - The declaration to be added to the symbol table
+ * @param includes - The SymbolFlags that node has in addition to its declaration type (eg: export, ambient, etc.)
+ * @param excludes - The flags which node cannot be declared alongside in a symbol table. Used to report forbidden declarations. 
+ */
  function declareSymbol(symbols: SymbolTable, parent: Symbol, node: Declaration, includes: SymbolFlags, excludes: SymbolFlags): Symbol {
  Debug.assert(!hasDynamicName(node));
 
@@ -144,15 +164,15 @@ module ts {
  let symbol: Symbol;
  if (name !== undefined) {
  symbol = hasProperty(symbols, name) ? symbols[name] : (symbols[name] = createSymbol(0, name));
- if (symbol.flags & excludes) {
+ if (symbol.flags & excludes || (node.kind === SyntaxKind.InterfaceDeclaration && hasNonAmbientClass(symbol))) {
  if (node.name) {
  node.name.parent = node;
  }
 
  // Report errors every position with duplicate declaration
  // Report errors on previous encountered declarations
  let message = symbol.flags & SymbolFlags.BlockScopedVariable
- ? Diagnostics.Cannot_redeclare_block_scoped_variable_0 
+ ? Diagnostics.Cannot_redeclare_block_scoped_variable_0
  : Diagnostics.Duplicate_identifier_0;
 
  forEach(symbol.declarations, declaration => {
@@ -249,7 +269,7 @@ module ts {
  // these cases are:
  // - node has locals (symbolKind & HasLocals) !== 0
  // - node is a source file
- setBlockScopeContainer(node, /*cleanLocals*/  (symbolKind & SymbolFlags.HasLocals) === 0 && node.kind !== SyntaxKind.SourceFile);
+ setBlockScopeContainer(node, /*cleanLocals*/ (symbolKind & SymbolFlags.HasLocals) === 0 && node.kind !== SyntaxKind.SourceFile);
  }
 
  forEachChild(node, bind);
@@ -403,7 +423,7 @@ module ts {
  declareModuleMember(node, symbolKind, symbolExcludes);
  break;
  }
-  // fall through.
+ // fall through.
  default:
  if (!blockScopeContainer.locals) {
  blockScopeContainer.locals = {};
@@ -424,7 +444,7 @@ module ts {
 
  function bind(node: Node) {
  node.parent = parent;
- 
+
  switch (node.kind) {
  case SyntaxKind.TypeParameter:
  bindDeclaration(<Declaration>node, SymbolFlags.TypeParameter, SymbolFlags.TypeParameterExcludes, /*isBlockScopeContainer*/ false);
@@ -516,7 +536,7 @@ module ts {
  bindCatchVariableDeclaration(<CatchClause>node);
  break;
  case SyntaxKind.ClassDeclaration:
- bindBlockScopedDeclaration(<Declaration>node, SymbolFlags.Class, SymbolFlags.ClassExcludes);
+ bindBlockScopedDeclaration(<Declaration>node, SymbolFlags.Class, isAmbientContext(node) ? SymbolFlags.AmbientClassExcludes : SymbolFlags.ClassExcludes);
  break;
  case SyntaxKind.InterfaceDeclaration:
  bindBlockScopedDeclaration(<Declaration>node, SymbolFlags.Interface, SymbolFlags.InterfaceExcludes);

src/compiler/types.ts

@@ -1473,7 +1473,8 @@ module ts {
  EnumMemberExcludes = Value,
  FunctionExcludes = Value & ~(Function | ValueModule),
  ClassExcludes = (Value | Type) & ~ValueModule,
- InterfaceExcludes = Type & ~Interface,
+ AmbientClassExcludes = (Value | Type) & ~(ValueModule | Interface),
+ InterfaceExcludes = Type & ~(Interface | Class),
  RegularEnumExcludes = (Value | Type) & ~(RegularEnum | ValueModule), // regular enums merge only with regular enums and modules
  ConstEnumExcludes = (Value | Type) & ~ConstEnum, // const enums merge only with const enums
  ValueModuleExcludes = Value & ~(Function | Class | RegularEnum | ValueModule),

tests/baselines/reference/classAndInterfaceMergeConflictingMembers.errors.txt

@@ -0,0 +1,44 @@
+tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts(2,12): error TS2300: Duplicate identifier 'x'.
+tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts(6,5): error TS2300: Duplicate identifier 'x'.
+tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts(10,15): error TS2300: Duplicate identifier 'x'.
+tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts(14,5): error TS2300: Duplicate identifier 'x'.
+tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts(18,13): error TS2300: Duplicate identifier 'x'.
+tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts(22,5): error TS2300: Duplicate identifier 'x'.
+
+
+==== tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts (6 errors) ====
+ declare class C1 {
+ public x : number;
+ ~
+!!! error TS2300: Duplicate identifier 'x'.
+ }
+
+ interface C1 {
+ x : number;
+ ~
+!!! error TS2300: Duplicate identifier 'x'.
+ }
+
+ declare class C2 {
+ protected x : number;
+ ~
+!!! error TS2300: Duplicate identifier 'x'.
+ }
+
+ interface C2 {
+ x : number;
+ ~
+!!! error TS2300: Duplicate identifier 'x'.
+ }
+
+ declare class C3 {
+ private x : number;
+ ~
+!!! error TS2300: Duplicate identifier 'x'.
+ }
+
+ interface C3 {
+ x : number;
+ ~
+!!! error TS2300: Duplicate identifier 'x'.
+ }

tests/baselines/reference/classAndInterfaceMergeConflictingMembers.js

@@ -0,0 +1,26 @@
+//// [classAndInterfaceMergeConflictingMembers.ts]
+declare class C1 {
+ public x : number;
+}
+
+interface C1 {
+ x : number;
+}
+
+declare class C2 {
+ protected x : number;
+}
+
+interface C2 {
+ x : number;
+}
+
+declare class C3 {
+ private x : number;
+}
+
+interface C3 {
+ x : number;
+}
+
+//// [classAndInterfaceMergeConflictingMembers.js]

tests/baselines/reference/declaredClassMergedwithSelf.errors.txt

@@ -0,0 +1,27 @@
+tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(1,15): error TS2300: Duplicate identifier 'C1'.
+tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(3,15): error TS2300: Duplicate identifier 'C1'.
+tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(5,15): error TS2300: Duplicate identifier 'C2'.
+tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(7,11): error TS2300: Duplicate identifier 'C2'.
+tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts(9,15): error TS2300: Duplicate identifier 'C2'.
+
+
+==== tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts (5 errors) ====
+ declare class C1 {}
+ ~~
+!!! error TS2300: Duplicate identifier 'C1'.
+
+ declare class C1 {}
+ ~~
+!!! error TS2300: Duplicate identifier 'C1'.
+
+ declare class C2 {}
+ ~~
+!!! error TS2300: Duplicate identifier 'C2'.
+
+ interface C2 {}
+ ~~
+!!! error TS2300: Duplicate identifier 'C2'.
+
+ declare class C2 {}
+ ~~
+!!! error TS2300: Duplicate identifier 'C2'.

tests/baselines/reference/declaredClassMergedwithSelf.js

@@ -0,0 +1,12 @@
+//// [declaredClassMergedwithSelf.ts]
+declare class C1 {}
+
+declare class C1 {}
+
+declare class C2 {}
+
+interface C2 {}
+
+declare class C2 {}
+
+//// [declaredClassMergedwithSelf.js]

tests/baselines/reference/mergedClassInterface.js

@@ -0,0 +1,14 @@
+//// [mergedClassInterface.ts]
+declare class C1 {}
+
+interface C1 {}
+
+interface C2 {}
+
+declare class C2 {}
+
+interface C2 {}
+
+interface C2 {}
+
+//// [mergedClassInterface.js]

tests/baselines/reference/mergedClassInterface.symbols

@@ -0,0 +1,19 @@
+=== tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts ===
+declare class C1 {}
+>C1 : Symbol(C1, Decl(mergedClassInterface.ts, 0, 0), Decl(mergedClassInterface.ts, 0, 19))
+
+interface C1 {}
+>C1 : Symbol(C1, Decl(mergedClassInterface.ts, 0, 0), Decl(mergedClassInterface.ts, 0, 19))
+
+interface C2 {}
+>C2 : Symbol(C2, Decl(mergedClassInterface.ts, 2, 15), Decl(mergedClassInterface.ts, 4, 15), Decl(mergedClassInterface.ts, 6, 19), Decl(mergedClassInterface.ts, 8, 15))
+
+declare class C2 {}
+>C2 : Symbol(C2, Decl(mergedClassInterface.ts, 2, 15), Decl(mergedClassInterface.ts, 4, 15), Decl(mergedClassInterface.ts, 6, 19), Decl(mergedClassInterface.ts, 8, 15))
+
+interface C2 {}
+>C2 : Symbol(C2, Decl(mergedClassInterface.ts, 2, 15), Decl(mergedClassInterface.ts, 4, 15), Decl(mergedClassInterface.ts, 6, 19), Decl(mergedClassInterface.ts, 8, 15))
+
+interface C2 {}
+>C2 : Symbol(C2, Decl(mergedClassInterface.ts, 2, 15), Decl(mergedClassInterface.ts, 4, 15), Decl(mergedClassInterface.ts, 6, 19), Decl(mergedClassInterface.ts, 8, 15))
+

tests/baselines/reference/mergedClassInterface.types

@@ -0,0 +1,19 @@
+=== tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts ===
+declare class C1 {}
+>C1 : C1
+
+interface C1 {}
+>C1 : C1
+
+interface C2 {}
+>C2 : C2
+
+declare class C2 {}
+>C2 : C2
+
+interface C2 {}
+>C2 : C2
+
+interface C2 {}
+>C2 : C2
+

tests/cases/conformance/classes/classDeclarations/classAndInterfaceMergeConflictingMembers.ts

@@ -0,0 +1,23 @@
+declare class C1 {
+ public x : number;
+}
+
+interface C1 {
+ x : number;
+}
+
+declare class C2 {
+ protected x : number;
+}
+
+interface C2 {
+ x : number;
+}
+
+declare class C3 {
+ private x : number;
+}
+
+interface C3 {
+ x : number;
+}

tests/cases/conformance/classes/classDeclarations/declaredClassMergedwithSelf.ts

@@ -0,0 +1,9 @@
+declare class C1 {}
+
+declare class C1 {}
+
+declare class C2 {}
+
+interface C2 {}
+
+declare class C2 {}

tests/cases/conformance/classes/classDeclarations/mergedClassInterface.ts

@@ -0,0 +1,11 @@
+declare class C1 {}
+
+interface C1 {}
+
+interface C2 {}
+
+declare class C2 {}
+
+interface C2 {}
+
+interface C2 {}