Review PR: Abstract classes

src/compiler/checker.ts

@@ -7092,6 +7092,11 @@ module ts {
                 return resolveErrorCall(node);
             }
 
+            var valueDecl = (expressionType.symbol ? expressionType.symbol.valueDeclaration : null);
+            if (valueDecl && valueDecl.flags & NodeFlags.Abstract) {
+                error(node, Diagnostics.Cannot_create_an_instance_of_the_abstract_class_1, valueDecl.name);
+            }
+
             // Technically, this signatures list may be incomplete. We are taking the apparent type,
             // but we are not including construct signatures that may have been added to the Object or
             // Function interface, since they have none by default. This is a bit of a leap of faith

src/compiler/declarationEmitter.ts

@@ -908,6 +908,10 @@ module ts {
 
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
+            if (node.flags & NodeFlags.Abstract) {
+                write("abstract ");
+            }
+
             write("class ");
             writeTextOfNode(currentSourceFile, node.name);
             let prevEnclosingDeclaration = enclosingDeclaration;

src/compiler/diagnosticInformationMap.generated.ts

@@ -365,6 +365,7 @@ module ts {
         An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2499, category: DiagnosticCategory.Error, key: "An interface can only extend an identifier/qualified-name with optional type arguments." },
         A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2500, category: DiagnosticCategory.Error, key: "A class can only implement an identifier/qualified-name with optional type arguments." },
         A_rest_element_cannot_contain_a_binding_pattern: { code: 2501, category: DiagnosticCategory.Error, key: "A rest element cannot contain a binding pattern." },
+        Cannot_create_an_instance_of_the_abstract_class_1: { code: 2501, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{1}'" },
         Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." },
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." },
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." },

src/compiler/diagnosticMessages.json

@@ -1447,6 +1447,10 @@
         "category": "Error",
         "code": 2501
     },
+    "Cannot create an instance of the abstract class '{1}'": {
+        "category": "Error",
+        "code": 2501
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

src/compiler/scanner.ts

@@ -83,6 +83,7 @@ module ts {
         "private": SyntaxKind.PrivateKeyword,
         "protected": SyntaxKind.ProtectedKeyword,
         "public": SyntaxKind.PublicKeyword,
+        "abstract": SyntaxKind.AbstractKeyword,
         "require": SyntaxKind.RequireKeyword,
         "return": SyntaxKind.ReturnKeyword,
         "set": SyntaxKind.SetKeyword,

src/compiler/types.ts

@@ -128,6 +128,7 @@ module ts {
         PrivateKeyword,
         ProtectedKeyword,
         PublicKeyword,
+        AbstractKeyword,
         StaticKeyword,
         YieldKeyword,
         // Contextual keywords
@@ -307,15 +308,16 @@ module ts {
         Protected =         0x00000040,  // Property/Method
         Static =            0x00000080,  // Property/Method
         Default =           0x00000100,  // Function/Class (export default declaration)
-        MultiLine =         0x00000200,  // Multi-line array or object literal
-        Synthetic =         0x00000400,  // Synthetic node (for full fidelity)
-        DeclarationFile =   0x00000800,  // Node is a .d.ts file
-        Let =               0x00001000,  // Variable declaration
-        Const =             0x00002000,  // Variable declaration
-        OctalLiteral =      0x00004000,
-        ExportContext =     0x00008000,  // Export context (initialized by binding)
-
-        Modifier = Export | Ambient | Public | Private | Protected | Static | Default,
+        Abstract =          0x00000200,
+        MultiLine =         0x00000400,  // Multi-line array or object literal
+        Synthetic =         0x00000800,  // Synthetic node (for full fidelity)
+        DeclarationFile =   0x00001000,  // Node is a .d.ts file
+        Let =               0x00002000,  // Variable declaration
+        Const =             0x00004000,  // Variable declaration
+        OctalLiteral =      0x00008000,
+        ExportContext =     0x00010000,  // Export context (initialized by binding)
+
+        Modifier = Export | Ambient | Public | Private | Protected | Static | Default | Abstract,
         AccessibilityModifier = Public | Private | Protected,
         BlockScoped = Let | Const
     }

src/compiler/utilities.ts

@@ -1137,6 +1137,7 @@ module ts {
 
     export function isModifier(token: SyntaxKind): boolean {
         switch (token) {
+            case SyntaxKind.AbstractKeyword:
             case SyntaxKind.PublicKeyword:
             case SyntaxKind.PrivateKeyword:
             case SyntaxKind.ProtectedKeyword:
@@ -1626,6 +1627,7 @@ module ts {
             case SyntaxKind.PublicKeyword: return NodeFlags.Public;
             case SyntaxKind.ProtectedKeyword: return NodeFlags.Protected;
             case SyntaxKind.PrivateKeyword: return NodeFlags.Private;
+            case SyntaxKind.AbstractKeyword: return NodeFlags.Abstract;
             case SyntaxKind.ExportKeyword: return NodeFlags.Export;
             case SyntaxKind.DeclareKeyword: return NodeFlags.Ambient;
             case SyntaxKind.ConstKeyword: return NodeFlags.Const;

tests/baselines/reference/APISample_linter.js

@@ -75,26 +75,26 @@ function delint(sourceFile) {
     delintNode(sourceFile);
     function delintNode(node) {
         switch (node.kind) {
-            case 186 /* ForStatement */:
-            case 187 /* ForInStatement */:
-            case 185 /* WhileStatement */:
-            case 184 /* DoStatement */:
-                if (node.statement.kind !== 179 /* Block */) {
+            case 187 /* ForStatement */:
+            case 188 /* ForInStatement */:
+            case 186 /* WhileStatement */:
+            case 185 /* DoStatement */:
+                if (node.statement.kind !== 180 /* Block */) {
                     report(node, "A looping statement's contents should be wrapped in a block body.");
                 }
                 break;
-            case 183 /* IfStatement */:
+            case 184 /* IfStatement */:
                 var ifStatement = node;
-                if (ifStatement.thenStatement.kind !== 179 /* Block */) {
+                if (ifStatement.thenStatement.kind !== 180 /* Block */) {
                     report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body.");
                 }
                 if (ifStatement.elseStatement &&
-                    ifStatement.elseStatement.kind !== 179 /* Block */ &&
-                    ifStatement.elseStatement.kind !== 183 /* IfStatement */) {
+                    ifStatement.elseStatement.kind !== 180 /* Block */ &&
+                    ifStatement.elseStatement.kind !== 184 /* IfStatement */) {
                     report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body.");
                 }
                 break;
-            case 169 /* BinaryExpression */:
+            case 170 /* BinaryExpression */:
                 var op = node.operatorToken.kind;
                 if (op === 28 /* EqualsEqualsToken */ || op == 29 /* ExclamationEqualsToken */) {
                     report(node, "Use '===' and '!=='.");

tests/baselines/reference/abstractClass1.errors.txt

@@ -0,0 +1,47 @@
+tests/cases/compiler/abstractClass1.ts(15,9): error TS2501: Cannot create an instance of the abstract class 'undefined'
+tests/cases/compiler/abstractClass1.ts(16,9): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/compiler/abstractClass1.ts(16,9): error TS2501: Cannot create an instance of the abstract class 'undefined'
+tests/cases/compiler/abstractClass1.ts(28,1): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/compiler/abstractClass1.ts(28,1): error TS2501: Cannot create an instance of the abstract class 'undefined'
+
+
+==== tests/cases/compiler/abstractClass1.ts (5 errors) ====
+
+    abstract class Foo {
+        constructor(f: any) { }
+        public static bar(): void { }
+
+        public empty() { }
+    }
+
+    class Bar extends Foo {
+        constructor(f: any) {
+            super(f);
+        }
+    }
+
+    var a = new Foo(1); // Error
+            ~~~~~~~~~~
+!!! error TS2501: Cannot create an instance of the abstract class 'undefined'
+    var b = new Foo(); // Error because of invalid constructor arguments
+            ~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+            ~~~~~~~~~
+!!! error TS2501: Cannot create an instance of the abstract class 'undefined'
+
+
+    // Valid
+
+    var c = new Bar(1);
+    c.empty();
+
+    // Calling a static method on a abstract class is valid
+    Foo.bar();
+
+    var Copy = Foo;
+    new Copy();
+    ~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    ~~~~~~~~~~
+!!! error TS2501: Cannot create an instance of the abstract class 'undefined'
+

tests/baselines/reference/abstractClass1.js

@@ -0,0 +1,76 @@
+//// [abstractClass1.ts]
+
+abstract class Foo {
+    constructor(f: any) { }
+    public static bar(): void { }
+
+    public empty() { }
+}
+
+class Bar extends Foo {
+    constructor(f: any) {
+        super(f);
+    }
+}
+
+var a = new Foo(1); // Error
+var b = new Foo(); // Error because of invalid constructor arguments
+
+
+// Valid
+
+var c = new Bar(1);
+c.empty();
+
+// Calling a static method on a abstract class is valid
+Foo.bar();
+
+var Copy = Foo;
+new Copy();
+
+
+//// [abstractClass1.js]
+var __extends = this.__extends || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var Foo = (function () {
+    function Foo(f) {
+    }
+    Foo.bar = function () { };
+    Foo.prototype.empty = function () { };
+    return Foo;
+})();
+var Bar = (function (_super) {
+    __extends(Bar, _super);
+    function Bar(f) {
+        _super.call(this, f);
+    }
+    return Bar;
+})(Foo);
+var a = new Foo(1); // Error
+var b = new Foo(); // Error because of invalid constructor arguments
+// Valid
+var c = new Bar(1);
+c.empty();
+// Calling a static method on a abstract class is valid
+Foo.bar();
+var Copy = Foo;
+new Copy();
+
+
+//// [abstractClass1.d.ts]
+declare abstract class Foo {
+    constructor(f: any);
+    static bar(): void;
+    empty(): void;
+}
+declare class Bar extends Foo {
+    constructor(f: any);
+}
+declare var a: Foo;
+declare var b: any;
+declare var c: Bar;
+declare var Copy: typeof Foo;

tests/cases/compiler/abstractClass1.ts

@@ -0,0 +1,29 @@
+// @declaration: true
+
+abstract class Foo {
+    constructor(f: any) { }
+    public static bar(): void { }
+
+    public empty() { }
+}
+
+class Bar extends Foo {
+    constructor(f: any) {
+        super(f);
+    }
+}
+
+var a = new Foo(1); // Error
+var b = new Foo(); // Error because of invalid constructor arguments
+
+
+// Valid
+
+var c = new Bar(1);
+c.empty();
+
+// Calling a static method on a abstract class is valid
+Foo.bar();
+
+var Copy = Foo;
+new Copy();