check argument for dynamic array 'add' method

src/eberon/EberonTypes.ob

@@ -1,5 +1,5 @@
 MODULE EberonTypes;
-IMPORT Code, Context, JsArray, LanguageContext, Procedure, Types;
+IMPORT Code, Context, Errors, JsArray, Language, LanguageContext, Procedure, Types;
 
 TYPE
     CallGenerator = PROCEDURE(cx: LanguageContext.PType; type: Types.DefinedProcedure): Procedure.PCallGenerator;
@@ -23,20 +23,22 @@ TYPE
     PDynamicArray* = POINTER TO DynamicArray;
 
     DynamicArrayMethodField = RECORD(Types.Field)
+        method: POINTER TO DynamicArrayMethod
     END;
+
     (*
     DynamicArrayAddCall = RECORD(Procedure.StdCall)
     END;
     *)
     DynamicArrayAddCallGenerator = RECORD(Procedure.CallGenerator)
-        arg: Code.PExpression
+        cx: LanguageContext.PType;
+        elementsType: Types.PType;
+        argCode: Procedure.PArgumentsCode
     END;
 
     DynamicArrayMethod = RECORD(Procedure.Std)
+        elementsType: Types.PType
     END;
-VAR
-    dynamicArrayAdd: POINTER TO DynamicArrayMethodField;
-    dynamicArrayAddMethod: POINTER TO DynamicArrayMethod;
 
 PROCEDURE arrayDimensionDescription*(VAR a: Types.Array): STRING;
 VAR
@@ -59,8 +61,14 @@ PROCEDURE DynamicArray.description(): STRING;
 END DynamicArray.description;
 
 PROCEDURE DynamicArray.denote(id: STRING): Types.PField;
+VAR
+    result: POINTER TO DynamicArrayMethodField;
 BEGIN
-    RETURN dynamicArrayAdd
+    NEW(result);
+    NEW(result.method);
+    result.method.name := "add";
+    result.method.elementsType := SELF.elementsType;
+    RETURN result
 END DynamicArray.denote;
 
 PROCEDURE MethodType.designatorCode(id: STRING): STRING;
@@ -106,14 +114,14 @@ PROCEDURE MethodVariable.idType(): STRING;
     RETURN "method"
 END MethodVariable.idType;
 
-PROCEDURE makeMethodVariable*(type: Types.PType): Types.PProcedureId;
+PROCEDURE makeMethod*(type: Types.PType): Types.PProcedureId;
 VAR
     result: POINTER TO MethodVariable;
 BEGIN
     NEW(result);
     result.type := type;
     RETURN result
-END makeMethodVariable;
+END makeMethod;
 
 PROCEDURE makeDynamicArray*(elementsType: Types.PType): PDynamicArray;
 VAR
@@ -133,32 +141,42 @@ PROCEDURE DynamicArrayMethodField.exported(): BOOLEAN;
 END DynamicArrayMethodField.exported;
 
 PROCEDURE DynamicArrayMethodField.type(): Types.PType;
-    RETURN dynamicArrayAddMethod
+    RETURN SELF.method
 END DynamicArrayMethodField.type;
 
 PROCEDURE DynamicArrayMethodField.asVar(): Types.PId;
-    RETURN makeMethodVariable(dynamicArrayAddMethod)
+    RETURN makeMethod(SELF.method)
 END DynamicArrayMethodField.asVar;
-(*
-PROCEDURE DynamicArrayAddCall.make(args: JsArray.Type; cx: LanguageContext.Type): Code.PExpression;
-BEGIN
-    arg <- Procedure.checkSingleArgument(args, SELF, cx.types);
-    RETURN Code.makeSimpleExpression(
-            SELF.varId + ".push(" + arg.code() + ")",
-            NIL)
-END DynamicArrayAddCall.make;
-*)
+
 PROCEDURE DynamicArrayAddCallGenerator.handleArgument(e: Code.PExpression);
 BEGIN
-    SELF.arg := e;
+    IF SELF.argCode # NIL THEN
+        Errors.raise("method 'add' expects one argument, got many");
+    END;
+
+    SELF.argCode := Procedure.makeArgumentsCode(SELF.cx);
+    Procedure.checkArgument(
+        e, 
+        Types.makeProcedureArgument(SELF.elementsType, FALSE), 
+        0, 
+        SELF.argCode, 
+        SELF.cx.types);
 END DynamicArrayAddCallGenerator.handleArgument;
 
 PROCEDURE DynamicArrayAddCallGenerator.end(): Code.PExpression;
+BEGIN
+    IF SELF.argCode = NIL THEN
+        Errors.raise("method 'add' expects one argument, got nothing");
+    END;
     RETURN Code.makeSimpleExpression(
-            "(" + SELF.arg.code() + ")",
+            "(" + SELF.argCode.result() + ")",
             NIL)
 END DynamicArrayAddCallGenerator.end;
 
+PROCEDURE DynamicArrayMethod.description(): STRING;
+    RETURN "dynamic array method '" + SELF.name + "'"
+END DynamicArrayMethod.description;
+
 PROCEDURE DynamicArrayMethod.designatorCode(id: STRING): STRING;
     RETURN "push"
 END DynamicArrayMethod.designatorCode;
@@ -168,11 +186,10 @@ VAR
     result: POINTER TO DynamicArrayAddCallGenerator;
 BEGIN
     NEW(result);
+    result.cx := cx;
+    result.elementsType := SELF.elementsType;
     RETURN result
 END DynamicArrayMethod.callGenerator;
 
 BEGIN
-    NEW(dynamicArrayAddMethod);
-    dynamicArrayAddMethod.name := "'add'";
-    NEW(dynamicArrayAdd);
 END EberonTypes.

src/eberon/eberon_context.js

@@ -359,7 +359,7 @@ var RecordFieldAsMethod = Context.RecordField.extend({
         Context.RecordField.prototype.init.call(this, field, type);
     },
     asVar: function(){ 
-        return EberonTypes.makeMethodVariable(this.type()); 
+        return EberonTypes.makeMethod(this.type()); 
     }
 });
 var RecordType = Type.Record.extend({

src/ob/Procedure.ob

@@ -55,14 +55,14 @@ TYPE
         call: PCall
     END;
 
-    ArgumentsCode = RECORD
+    ArgumentsCode* = RECORD
         PROCEDURE write(actual: Code.PExpression; 
                         expected: Types.PProcedureArgument; 
                         cast: Cast.PCastOp
                         );
-        PROCEDURE result(): STRING
+        PROCEDURE result*(): STRING
     END;
-    PArgumentsCode = POINTER TO ArgumentsCode;
+    PArgumentsCode* = POINTER TO ArgumentsCode;
 
     GenArgCode = RECORD(ArgumentsCode)
         code: STRING;
@@ -74,7 +74,7 @@ TYPE
 VAR
     predefined*: JsArray.Type;
 
-PROCEDURE checkArgument(
+PROCEDURE checkArgument*(
     actual: Code.PExpression; 
     expected: Types.PProcedureArgument; 
     pos: INTEGER;

src/ob/Types.ob

@@ -96,7 +96,7 @@ TYPE
     END;
 
     Array* = RECORD(NamedType)
-        elementsType: PType
+        elementsType-: PType
     END;
     PArray* = POINTER TO Array;
 

test/expected/eberon/dynamic_array.js

@@ -55,7 +55,19 @@ var r = new T();
 function assignDynamicArrayFromStatic(){
 	var static$ = RTL$.makeArray(3, 0);
 	var dynamic = [];
+	var dynamicString = [];
+	var dynamicByte = [];
+	var i = 0;
+	var s = '';
+	var byte = 0;
 	RTL$.copy(static$, dynamic);
 	dynamic.push(3);
+	dynamic.push(i);
+	dynamic.push(byte);
+	dynamicString.push("abc");
+	dynamicString.push("\"");
+	dynamicString.push(s);
+	dynamicByte.push(byte);
+	dynamicByte.push(i & 0xFF);
 }
 }();

test/input/eberon/dynamic_array.ob

@@ -11,10 +11,24 @@ PROCEDURE assignDynamicArrayFromStatic();
 VAR 
     static: ARRAY 3 OF INTEGER;
     dynamic: ARRAY * OF INTEGER;
+    dynamicString: ARRAY * OF STRING;
+    dynamicByte: ARRAY * OF BYTE;
+    i: INTEGER;
+    s: STRING;
+    byte: BYTE;
 BEGIN
     dynamic := static;
 
     dynamic.add(3);
+    dynamic.add(i);
+    dynamic.add(byte);
+
+    dynamicString.add("abc");
+    dynamicString.add(22X);
+    dynamicString.add(s);
+    
+    dynamicByte.add(byte);
+    dynamicByte.add(i);
 END assignDynamicArrayFromStatic;
 
 END m.

test/test_unit_eberon.js

@@ -931,10 +931,14 @@ exports.suite = {
         ),
         "add": testWithContext(
             context(grammar.statement, 
-                    "VAR a: ARRAY * OF INTEGER;"),
-            pass("a.add(123)"),
+                    "VAR a: ARRAY * OF INTEGER; byte: BYTE;"),
+            pass("a.add(123)",
+                 "a.add(byte)"),
             fail(["a.add := NIL", "cannot assign to method"],
-                 ["v <- a.add", "standard procedure 'add' cannot be referenced"]                
+                 ["v <- a.add", "dynamic array method 'add' cannot be referenced"],                
+                 ["a.add()", "method 'add' expects one argument, got nothing"],
+                 ["a.add(1, 2)", "method 'add' expects one argument, got many"],                
+                 ["a.add(TRUE)", "type mismatch for argument 1: 'BOOLEAN' cannot be converted to 'INTEGER'"]                
                 )
         )
     }