Implement calls to 'super()' (#445)

Author: dcodeIO

src/ast.ts

@@ -120,7 +120,8 @@ export function nodeIsCallable(kind: NodeKind): bool {
     case NodeKind.CALL:
     case NodeKind.ELEMENTACCESS:
     case NodeKind.PARENTHESIZED:
-    case NodeKind.PROPERTYACCESS: return true;
+    case NodeKind.PROPERTYACCESS:
+    case NodeKind.SUPER: return true;
   }
   return false;
 }

src/compiler.ts

@@ -1095,6 +1095,8 @@ export class Compiler extends DiagnosticEmitter {
         if (isConstructor) {
           let nativeSizeType = this.options.nativeSizeType;
           assert(instance.is(CommonFlags.INSTANCE));
+          let parent = assert(instance.parent);
+          assert(parent.kind == ElementKind.CLASS);
 
           // implicitly return `this` if the constructor doesn't always return on its own
           if (!flow.is(FlowFlags.RETURNS)) {
@@ -1105,14 +1107,20 @@ export class Compiler extends DiagnosticEmitter {
 
             // if not all branches are guaranteed to allocate, also append a conditional allocation
             } else {
-              let parent = assert(instance.parent);
-              assert(parent.kind == ElementKind.CLASS);
               stmts.push(module.createTeeLocal(0,
                 this.makeConditionalAllocate(<Class>parent, declaration.name)
               ));
             }
           }
 
+          // check that super has been called if this is a derived class
+          if ((<Class>parent).base && !flow.is(FlowFlags.CALLS_SUPER)) {
+            this.error(
+              DiagnosticCode.Constructors_for_derived_classes_must_contain_a_super_call,
+              instance.prototype.declaration.range
+            );
+          }
+
         // make sure all branches return
         } else if (returnType != Type.void && !flow.is(FlowFlags.RETURNS)) {
           this.error(
@@ -5230,6 +5238,43 @@ export class Compiler extends DiagnosticEmitter {
         break;
       }
 
+      case ElementKind.CLASS: {
+
+        // call to `super()`
+        if (expression.expression.kind == NodeKind.SUPER) {
+          if (!currentFunction.is(CommonFlags.CONSTRUCTOR)) {
+            this.error(
+              DiagnosticCode.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors,
+              expression.range
+            );
+            return module.createUnreachable();
+          }
+
+          let classInstance = assert(currentFunction.parent);
+          assert(classInstance.kind == ElementKind.CLASS);
+          let expr = this.compileSuperInstantiate(<Class>classInstance, expression.arguments, expression);
+          this.currentType = Type.void;
+
+          // check that super() is called before allocation is performed (incl. in super arguments)
+          let flow = currentFunction.flow;
+          if (flow.isAny(
+            FlowFlags.ALLOCATES |
+            FlowFlags.CONDITIONALLY_ALLOCATES
+          )) {
+            this.error(
+              DiagnosticCode._super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class,
+              expression.range
+            );
+            return module.createUnreachable();
+          }
+          flow.set(FlowFlags.ALLOCATES | FlowFlags.CALLS_SUPER);
+
+          let thisLocal = assert(this.currentFunction.flow.getScopedLocal("this"));
+          return module.createSetLocal(thisLocal.index, expr);
+        }
+        // otherwise fall-through
+      }
+
       // not supported
       default: {
         this.error(
@@ -6027,6 +6072,15 @@ export class Compiler extends DiagnosticEmitter {
         return module.createUnreachable();
       }
       case NodeKind.SUPER: {
+        if (currentFunction.is(CommonFlags.CONSTRUCTOR)) {
+          if (!currentFunction.flow.is(FlowFlags.CALLS_SUPER)) {
+            // TS1034 in the parser effectively limits this to property accesses
+            this.error(
+              DiagnosticCode._super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class,
+              expression.range
+            );
+          }
+        }
         let flow = currentFunction.flow;
         if (flow.is(FlowFlags.INLINE_CONTEXT)) {
           let scopedThis = flow.getScopedLocal("this");
@@ -6658,6 +6712,37 @@ export class Compiler extends DiagnosticEmitter {
     return expr;
   }
 
+  compileSuperInstantiate(classInstance: Class, argumentExpressions: Expression[], reportNode: Node): ExpressionRef {
+    // traverse to the top-most visible constructor (except the current one)
+    var currentClassInstance: Class | null = classInstance.base;
+    var constructorInstance: Function | null = null;
+    while (currentClassInstance) {
+      constructorInstance = currentClassInstance.constructorInstance;
+      if (constructorInstance) break; // TODO: check visibility
+      currentClassInstance = currentClassInstance.base;
+    }
+
+    // if a constructor is present, allocate the necessary memory for `this` and call it
+    var expr: ExpressionRef;
+    if (constructorInstance) {
+      expr = this.compileCallDirect(constructorInstance, argumentExpressions, reportNode,
+        this.makeAllocate(classInstance, reportNode)
+      );
+
+    // otherwise simply allocate a new instance and initialize its fields
+    } else {
+      if (argumentExpressions.length) {
+        this.error(
+          DiagnosticCode.Expected_0_arguments_but_got_1,
+          reportNode.range, "0", argumentExpressions.length.toString(10)
+        );
+      }
+      expr = this.makeAllocate(classInstance, reportNode);
+    }
+    this.currentType = classInstance.type;
+    return expr;
+  }
+
   compileParenthesizedExpression(
     expression: ParenthesizedExpression,
     contextualType: Type

src/diagnosticMessages.generated.ts

@@ -66,6 +66,7 @@ export enum DiagnosticCode {
   Unexpected_end_of_text = 1126,
   Invalid_character = 1127,
   _case_or_default_expected = 1130,
+  _super_must_be_followed_by_an_argument_list_or_member_access = 1034,
   A_declare_modifier_cannot_be_used_in_an_already_ambient_context = 1038,
   Type_argument_expected = 1140,
   String_literal_expected = 1141,
@@ -94,13 +95,16 @@ export enum DiagnosticCode {
   Index_signature_is_missing_in_type_0 = 2329,
   _this_cannot_be_referenced_in_current_location = 2332,
   _super_can_only_be_referenced_in_a_derived_class = 2335,
+  Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors = 2337,
   Property_0_does_not_exist_on_type_1 = 2339,
   Cannot_invoke_an_expression_whose_type_lacks_a_call_signature_Type_0_has_no_compatible_call_signatures = 2349,
   Cannot_use_new_with_an_expression_whose_type_lacks_a_construct_signature = 2351,
   A_function_whose_declared_type_is_not_void_must_return_a_value = 2355,
   The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access = 2357,
   The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access = 2364,
   Operator_0_cannot_be_applied_to_types_1_and_2 = 2365,
+  A_super_call_must_be_the_first_statement_in_the_constructor = 2376,
+  Constructors_for_derived_classes_must_contain_a_super_call = 2377,
   _get_and_set_accessor_must_have_the_same_type = 2380,
   Constructor_implementation_is_missing = 2390,
   Function_implementation_is_missing_or_not_immediately_following_the_declaration = 2391,
@@ -124,7 +128,9 @@ export enum DiagnosticCode {
   Required_type_parameters_may_not_follow_optional_type_parameters = 2706,
   File_0_not_found = 6054,
   Numeric_separators_are_not_allowed_here = 6188,
-  Multiple_consecutive_numeric_separators_are_not_permitted = 6189
+  Multiple_consecutive_numeric_separators_are_not_permitted = 6189,
+  _super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class = 17009,
+  _super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class = 17011
 }
 
 /** Translates a diagnostic code to its respective string. */
@@ -189,6 +195,7 @@ export function diagnosticCodeToString(code: DiagnosticCode): string {
     case 1126: return "Unexpected end of text.";
     case 1127: return "Invalid character.";
     case 1130: return "'case' or 'default' expected.";
+    case 1034: return "'super' must be followed by an argument list or member access.";
     case 1038: return "A 'declare' modifier cannot be used in an already ambient context.";
     case 1140: return "Type argument expected.";
     case 1141: return "String literal expected.";
@@ -217,13 +224,16 @@ export function diagnosticCodeToString(code: DiagnosticCode): string {
     case 2329: return "Index signature is missing in type '{0}'.";
     case 2332: return "'this' cannot be referenced in current location.";
     case 2335: return "'super' can only be referenced in a derived class.";
+    case 2337: return "Super calls are not permitted outside constructors or in nested functions inside constructors.";
     case 2339: return "Property '{0}' does not exist on type '{1}'.";
     case 2349: return "Cannot invoke an expression whose type lacks a call signature. Type '{0}' has no compatible call signatures.";
     case 2351: return "Cannot use 'new' with an expression whose type lacks a construct signature.";
     case 2355: return "A function whose declared type is not 'void' must return a value.";
     case 2357: return "The operand of an increment or decrement operator must be a variable or a property access.";
     case 2364: return "The left-hand side of an assignment expression must be a variable or a property access.";
     case 2365: return "Operator '{0}' cannot be applied to types '{1}' and '{2}'.";
+    case 2376: return "A 'super' call must be the first statement in the constructor.";
+    case 2377: return "Constructors for derived classes must contain a 'super' call.";
     case 2380: return "'get' and 'set' accessor must have the same type.";
     case 2390: return "Constructor implementation is missing.";
     case 2391: return "Function implementation is missing or not immediately following the declaration.";
@@ -248,6 +258,8 @@ export function diagnosticCodeToString(code: DiagnosticCode): string {
     case 6054: return "File '{0}' not found.";
     case 6188: return "Numeric separators are not allowed here.";
     case 6189: return "Multiple consecutive numeric separators are not permitted.";
+    case 17009: return "'super' must be called before accessing 'this' in the constructor of a derived class.";
+    case 17011: return "'super' must be called before accessing a property of 'super' in the constructor of a derived class.";
     default: return "";
   }
 }

src/diagnosticMessages.json

@@ -59,6 +59,7 @@
   "Unexpected end of text.": 1126,
   "Invalid character.": 1127,
   "'case' or 'default' expected.": 1130,
+  "'super' must be followed by an argument list or member access.": 1034,
   "A 'declare' modifier cannot be used in an already ambient context.": 1038,
   "Type argument expected.": 1140,
   "String literal expected.": 1141,
@@ -88,13 +89,16 @@
   "Index signature is missing in type '{0}'.": 2329,
   "'this' cannot be referenced in current location.": 2332,
   "'super' can only be referenced in a derived class.": 2335,
+  "Super calls are not permitted outside constructors or in nested functions inside constructors.": 2337,
   "Property '{0}' does not exist on type '{1}'.": 2339,
   "Cannot invoke an expression whose type lacks a call signature. Type '{0}' has no compatible call signatures.": 2349,
   "Cannot use 'new' with an expression whose type lacks a construct signature.": 2351,
   "A function whose declared type is not 'void' must return a value.": 2355,
   "The operand of an increment or decrement operator must be a variable or a property access.": 2357,
   "The left-hand side of an assignment expression must be a variable or a property access.": 2364,
   "Operator '{0}' cannot be applied to types '{1}' and '{2}'.": 2365,
+  "A 'super' call must be the first statement in the constructor.": 2376,
+  "Constructors for derived classes must contain a 'super' call.": 2377,
   "'get' and 'set' accessor must have the same type.": 2380,
   "Constructor implementation is missing.": 2390,
   "Function implementation is missing or not immediately following the declaration.": 2391,
@@ -119,5 +123,7 @@
 
   "File '{0}' not found.": 6054,
   "Numeric separators are not allowed here.": 6188,
-  "Multiple consecutive numeric separators are not permitted.": 6189
+  "Multiple consecutive numeric separators are not permitted.": 6189,
+  "'super' must be called before accessing 'this' in the constructor of a derived class.": 17009,
+  "'super' must be called before accessing a property of 'super' in the constructor of a derived class.": 17011
 }

src/parser.ts

@@ -3337,6 +3337,12 @@ export class Parser extends DiagnosticEmitter {
         return Node.createConstructorExpression(tn.range(startPos, tn.pos));
       }
       case Token.SUPER: {
+        if (tn.peek() != Token.DOT && tn.nextToken != Token.OPENPAREN) {
+          this.error(
+            DiagnosticCode._super_must_be_followed_by_an_argument_list_or_member_access,
+            tn.range()
+          );
+        }
         return Node.createSuperExpression(tn.range(startPos, tn.pos));
       }
       case Token.STRINGLITERAL: {

src/program.ts

@@ -3041,26 +3041,28 @@ export const enum FlowFlags {
   CONTINUES = 1 << 4,
   /** This branch always allocates. Constructors only. */
   ALLOCATES = 1 << 5,
+  /** This branch always calls super. Constructors only. */
+  CALLS_SUPER = 1 << 6,
 
   // conditional
 
   /** This branch conditionally returns in a child branch. */
-  CONDITIONALLY_RETURNS = 1 << 6,
+  CONDITIONALLY_RETURNS = 1 << 7,
   /** This branch conditionally throws in a child branch. */
-  CONDITIONALLY_THROWS = 1 << 7,
+  CONDITIONALLY_THROWS = 1 << 8,
   /** This branch conditionally breaks in a child branch. */
-  CONDITIONALLY_BREAKS = 1 << 8,
+  CONDITIONALLY_BREAKS = 1 << 9,
   /** This branch conditionally continues in a child branch. */
-  CONDITIONALLY_CONTINUES = 1 << 9,
+  CONDITIONALLY_CONTINUES = 1 << 10,
   /** This branch conditionally allocates in a child branch. Constructors only. */
-  CONDITIONALLY_ALLOCATES = 1 << 10,
+  CONDITIONALLY_ALLOCATES = 1 << 11,
 
   // special
 
   /** This branch is part of inlining a function. */
-  INLINE_CONTEXT = 1 << 11,
+  INLINE_CONTEXT = 1 << 12,
   /** This branch explicitly requests no bounds checking. */
-  UNCHECKED_CONTEXT = 1 << 12,
+  UNCHECKED_CONTEXT = 1 << 13,
 
   // masks
 
@@ -3076,7 +3078,8 @@ export const enum FlowFlags {
                   | FlowFlags.THROWS
                   | FlowFlags.BREAKS
                   | FlowFlags.CONTINUES
-                  | FlowFlags.ALLOCATES,
+                  | FlowFlags.ALLOCATES
+                  | FlowFlags.CALLS_SUPER,
 
   /** Any conditional flag. */
   ANY_CONDITIONAL = FlowFlags.CONDITIONALLY_RETURNS

src/resolver.ts

@@ -1242,8 +1242,16 @@ export class Resolver extends DiagnosticEmitter {
 
           // Lay out fields in advance
           case ElementKind.FIELD_PROTOTYPE: {
-            if (!instance.members) instance.members = new Map();
             let fieldDeclaration = (<FieldPrototype>member).declaration;
+            if (!instance.members) instance.members = new Map();
+            else if (instance.members.has(member.simpleName)) {
+              this.error(
+                DiagnosticCode.Duplicate_identifier_0,
+                fieldDeclaration.name.range,
+                member.simpleName
+              );
+              break;
+            }
             let fieldType: Type | null = null;
             // TODO: handle duplicate non-private fields
             if (!fieldDeclaration.type) {