Merged Declarations for Classes and Interfaces

src/compiler/binder.ts

@@ -135,6 +135,23 @@ module ts {
             return node.name ? declarationNameToString(node.name) : getDeclarationName(node);
         }
 
+        /**
+         * Checks if the symbol contains a class declaration that is non-ambient.
+         */
+        function hasNonAmbientClass(symbol: Symbol): boolean {
+            return symbol && forEach(symbol.declarations, (element: Declaration) => {
+                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 +161,18 @@ module ts {
             let symbol: Symbol;
             if (name !== undefined) {
                 symbol = hasProperty(symbols, name) ? symbols[name] : (symbols[name] = createSymbol(0, name));
-                if (symbol.flags & excludes) {
+
+                // Check for declarations 'node' cannot be merged with. 
+                // Interfaces declarations cannot be merged with non-ambient class declarations, which isn't encoded in SymbolFlags.
+                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);
@@ -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 {}