Initialize records fields with custom constructors.

src/eberon/EberonRecord.ob

@@ -8,9 +8,11 @@ TYPE
         PROCEDURE defineMethod(methodId: Context.PIdentdefInfo; type: EberonTypes.PMethodType);
         PROCEDURE requireNewOnly();
         PROCEDURE setBaseConstructorCallCode(code: STRING);
+        PROCEDURE setFieldInitializationCode(field: STRING; code: STRING);
         PROCEDURE setRecordInitializationCode(baseConstructorCallCode, fieldsInitializationCode, inheritanceCode: STRING);
 
         customConstructor-: Types.PDefinedProcedure;
+        customInitedfields-: ARRAY * OF STRING;
         finalized: BOOLEAN;
         declaredMethods: JsMap.Type;
         definedMethods: ARRAY * OF STRING;
@@ -21,6 +23,7 @@ TYPE
         lazyDefinitions: JsMap.Type;
         nonExportedMethods: ARRAY * OF STRING;
         inheritanceCode, baseConstructorCallCode-, fieldsInitializationCode-: STRING;
+        fieldsInit: JsMap.Strings;
     END;
     PRecord* = POINTER TO Record;
 
@@ -237,6 +240,14 @@ BEGIN
         Errors.raise(
             "cannot declare field, record already has method '" + id +"'");
     END;
+
+    type <- f.type();
+    IF (type IS PRecord) 
+        & (type.customConstructor # NIL) 
+        & (LEN(type.customConstructor.args()) # 0) THEN
+        SELF.customInitedfields.add(id);
+    END;
+
     SUPER(f);
 END;
 
@@ -303,6 +314,11 @@ BEGIN
     SELF.baseConstructorCallCode := code;
 END;
 
+PROCEDURE Record.setFieldInitializationCode(field: STRING; code: STRING);
+BEGIN
+    JsMap.putString(SELF.fieldsInit, field, code);
+END;
+
 PROCEDURE Record.setRecordInitializationCode(baseConstructorCallCode, fieldsInitializationCode, inheritanceCode: STRING);
 BEGIN
     SELF.baseConstructorCallCode := baseConstructorCallCode;
@@ -382,6 +398,7 @@ BEGIN
     Types.initRecord(result, name, cons, scope);
     result.declaredMethods := JsMap.make();
     result.lazyDefinitions := JsMap.make();
+    result.fieldsInit := JsMap.makeStrings();
     RETURN result;
 END;
 

src/eberon/eberon_context.js

@@ -472,32 +472,49 @@ function handleTypePromotionMadeInSeparateStatement(msg){
 }
 
 function getConstructorSuperMsg(){}
+function getConstructorBoundType(){}
+
+function InitFieldMsg(id){
+    this.id = id;
+}
 
 var BaseInit = Context.Chained.extend({
     init: function EberonContext$BaseInit(parent){
         Context.Chained.prototype.init.call(this, parent);
         this.__type = undefined;
-        this.__baseConstructorCall = undefined;
+        this.__initCall = undefined;
+        this.__initField = undefined;
+    },
+    type: function(){
+        if (!this.__type)
+            this.__type = this.handleMessage(getConstructorBoundType);
+        return this.__type;
     },
     codeGenerator: function(){return CodeGenerator.nullGenerator();},
     handleMessage: function(msg){
         if (msg == Context.beginCallMsg)
             return;
         if (msg == Context.endCallMsg){
-            var e = this.__baseConstructorCall.end();
-            this.__type.setBaseConstructorCallCode(e.code());
+            var e = this.__initCall.end();
+            if (this.__initField)
+                this.type().setFieldInitializationCode(this.__initField, e.code());
+            else
+                this.type().setBaseConstructorCallCode(e.code());
             return;
         }
         return Context.Chained.prototype.handleMessage.call(this, msg);
     },
+    handleIdent: function(id){
+        this.__initField = id;
+        this.__initCall = this.handleMessage(new InitFieldMsg(id));
+    },
     handleExpression: function(e){
-        this.__baseConstructorCall.handleArgument(e);
+        this.__initCall.handleArgument(e);
     },
     handleLiteral: function(s){
         if (s == "SUPER"){
             var ms = this.handleMessage(getConstructorSuperMsg);
-            this.__type = ms.type;
-            this.__baseConstructorCall = makeConstructorCall(this, Type.recordBase(this.__type), EberonConstructor.makeBaseConstructorCall);
+            this.__initCall = makeConstructorCall(this, Type.recordBase(this.type()), EberonConstructor.makeBaseConstructorCall);
         }
     }
 });
@@ -511,6 +528,7 @@ var ProcOrMethodDecl = Context.ProcDecl.extend({
         this.__endingId = undefined;
         this.__isConstructor = false;
         this.__baseConstructorWasCalled = false;
+        this.__initedFields = [];
     },
     handleMessage: function(msg){
         if (msg == getMethodSelf){
@@ -523,6 +541,9 @@ var ProcOrMethodDecl = Context.ProcDecl.extend({
             return this.__boundType;
         }
 
+        if (msg == getConstructorBoundType)
+            return this.__boundType;
+
         if (msg == getConstructorSuperMsg){
             this.__baseConstructorWasCalled = true;
             return this.__handleSuperCall();
@@ -534,6 +555,9 @@ var ProcOrMethodDecl = Context.ProcDecl.extend({
             return this.__handleSuperCall();
         }
 
+        if (msg instanceof InitFieldMsg)
+            return this.__handleFieldInit(msg.id);
+
         if (msg instanceof MethodOrProcMsg){
             var id = msg.id;
             var type = msg.type;
@@ -614,6 +638,16 @@ var ProcOrMethodDecl = Context.ProcDecl.extend({
                     throw new Errors.Error("base record constructor has parameters but was not called (use '| SUPER' to pass parameters to base constructor)");
                 if (this.__baseConstructorWasCalled && (!base.customConstructor || !base.customConstructor.args().length))
                     throw new Errors.Error("base record constructor has no parameters and will be called automatically (do not use '| SUPER' to call base constructor)");
+                
+                var fieldsWereNotInited = [];
+                for(var i = 0; i < this.__boundType.customInitedfields.length; ++i){
+                    var f = this.__boundType.customInitedfields[i];
+                    if (this.__initedFields.indexOf(f) == -1)
+                        fieldsWereNotInited.push(f);
+                }
+                if (fieldsWereNotInited.length)
+                    throw new Errors.Error("constructor '" + Type.typeName(this.__boundType) + "' must initialize fields: " + fieldsWereNotInited);
+
                 this.codeGenerator().write(
                     this.__boundType.defineConstructor(this.__methodType.procType()));
             }
@@ -636,12 +670,26 @@ var ProcOrMethodDecl = Context.ProcDecl.extend({
             EberonRecord.requireMethodDefinition(baseType, id, "cannot use abstract method(s) in SUPER calls");
         
         return {
-            type: this.__boundType,
             info: this.__isConstructor ? undefined
                                        : Type.makeProcedure(EberonTypes.makeMethodType(id, this.__methodType.procType(), superMethodCallGenerator)),
             code: this.qualifyScope(Type.recordScope(baseType))
                 + Type.typeName(baseType) + ".prototype." + id + ".call"
         };
+    },
+    __handleFieldInit: function(id){
+        var fields = Type.recordOwnFields(this.__boundType);
+        if (!fields.hasOwnProperty(id))
+            throw new Errors.Error("'" + id + "' is not record '" + Type.typeName(this.__boundType) + "' own field");
+        
+        if (this.__initedFields.indexOf(id) != -1)
+            throw new Errors.Error("field '" + id + "' is already initialized");
+
+        this.__initedFields.push(id);        
+        var type = fields[id].type();
+        if (!(type instanceof Type.Record))
+            throw new Errors.Error("cannot initialize field '" + id + "', only fields of record types are supported");
+
+        return makeConstructorCall(this, type, EberonConstructor.makeConstructorCall);
     }
 });
 

src/eberon/eberon_grammar.js

@@ -91,9 +91,13 @@ function makeFormalArray(){
     return and("ARRAY", optional("*"), "OF");
 }
 
-function makeFormalResult(base, actualParameters){
+function makeFormalResult(base, ident, actualParameters){
+    var initField = and(ident, actualParameters);
+    var followingFields = repeat(and(",", initField));
     return or(base, 
-              context(and("|", "SUPER", actualParameters), EbContext.BaseInit));
+              context(and("|", or(and("SUPER", actualParameters, followingFields),
+                                  and(initField, followingFields))), 
+                      EbContext.BaseInit));
 }
 
 function makeReturn(base){

src/grammar.js

@@ -178,7 +178,7 @@ var formalParameters = and(
           "("
         , optional(context(and(fpSection, repeat(and(";", fpSection))), Context.ProcParams))
         , required( ")" )
-        , optional(makeFormalResult(and(":", qualident), actualParameters)));
+        , optional(makeFormalResult(and(":", qualident), ident, actualParameters)));
 
 var procedureType = and("PROCEDURE"
                       , context(optional(formalParameters), contexts.FormalParameters)

src/ob/JsMap.ob

@@ -16,6 +16,14 @@ BEGIN
     RETURN result    
 END make;
 
+PROCEDURE makeStrings*(): Strings;
+VAR
+    result: Strings;
+BEGIN
+    JS.do("result = {}");
+    RETURN result    
+END;
+
 PROCEDURE has*(m: Type; s: STRING): BOOLEAN;
 VAR
     result: BOOLEAN;
@@ -37,6 +45,11 @@ BEGIN
     JS.do("m[s] = o");
 END put;
 
+PROCEDURE putString*(m: Strings; s: STRING; v: STRING);
+BEGIN
+    JS.do("m[s] = v");
+END;
+
 PROCEDURE erase*(m: Type; s: STRING);
 BEGIN
     JS.do("delete m[s]");

test/test_unit_eberon.js

@@ -1138,6 +1138,35 @@ exports.suite = {
              ["PROCEDURE DerivedWthoutConstructor() | SUPER(); END;", "base record constructor has no parameters and will be called automatically (do not use '| SUPER' to call base constructor)"],
              ["PROCEDURE DerivedWthConstructorNoParameters() | SUPER(); END;", "base record constructor has no parameters and will be called automatically (do not use '| SUPER' to call base constructor)"]
             )
+        ),
+    "initialize fields": testWithModule(
+            "MODULE m;"
+          + "TYPE Field* = RECORD END;"
+          + "PROCEDURE Field(a: INTEGER); END;"
+          + "END m.",
+        pass("MODULE m2; IMPORT m; TYPE T = RECORD f: m.Field; END; PROCEDURE T() | f(123); END; END m2."),
+        fail(["MODULE m2; IMPORT m; TYPE T = RECORD f: m.Field; END; PROCEDURE T(); END; END m2.", 
+              "constructor 'T' must initialize fields: f"],
+             ["MODULE m2; TYPE T = RECORD END; PROCEDURE T() | unknownField(123); END; END m2.", 
+              "'unknownField' is not record 'T' own field"],
+             ["MODULE m2; IMPORT m; TYPE T = RECORD f: m.Field; END; Derived = RECORD(T) END; PROCEDURE Derived() | f(123); END; END m2.", 
+              "'f' is not record 'Derived' own field"],
+             ["MODULE m2; IMPORT m; TYPE T = RECORD f: m.Field; END; PROCEDURE T() | f(123), f(123); END; END m2.", 
+              "field 'f' is already initialized"],
+             ["MODULE m2; TYPE T = RECORD i: INTEGER; END; PROCEDURE T() | i(); END; END m2.", 
+              "cannot initialize field 'i', only fields of record types are supported"],
+             ["MODULE m2; TYPE T = RECORD i: INTEGER; END; PROCEDURE T() | i(123); END; END m2.", 
+              "cannot initialize field 'i', only fields of record types are supported"]
+             )
+        ),
+    "call base and initialize fields": testWithContext(
+        context(grammar.declarationSequence,
+                "TYPE Field = RECORD END; T = RECORD END; Derived = RECORD(T) f: Field; END;"
+              + "PROCEDURE Field(a: INTEGER); END;"
+              + "PROCEDURE T(a: INTEGER); END;"
+              ),
+        pass("PROCEDURE Derived() | SUPER(123), f(456); END;"),
+        fail(["PROCEDURE Derived() | f(456), SUPER(123); END;", "not parsed"])
         )
     }
 };