using operator NEW and constructors

src/context.js

@@ -219,7 +219,7 @@ exports.String = ChainedContext.extend({
     toStr: function(s){return s;},
     endParse: function(){
         var s = this.toStr(this.__result);
-        this.parent().handleConst(Type.makeString(s), Code.makeStringConst(s), escapeString(s));
+        this.parent().handleConst(new Type.String(s), Code.makeStringConst(s), escapeString(s));
         }
 });
 
@@ -282,7 +282,7 @@ exports.Identdef = ChainedContext.extend({
         this.parent().handleIdentdef(this._makeIdendef());
     },
     _makeIdendef: function(){
-        return ObContext.makeIdentdefInfo(this._id, this._export);
+        return new ObContext.IdentdefInfo(this._id, this._export);
     }
 });
 
@@ -437,7 +437,7 @@ exports.Designator = ChainedContext.extend({
         var self = this;
         var refCode = function(code){return self.__makeRefCode(code);};
         this.parent().setDesignator(
-            Code.makeDesignator(code, this.__lval ? this.__lval : code, refCode, this.__currentType, this.__info, this.__scope));
+            new Code.Designator(code, this.__lval ? this.__lval : code, refCode, this.__currentType, this.__info, this.__scope));
     },
     __makeRefCode: function(code){
         if (   this.__currentType instanceof Type.Array
@@ -476,7 +476,7 @@ exports.FormalType = HandleSymbolAsType.extend({
     },
     setType: function(type){           
         for(var i = 0; i < this.__arrayDimension; ++i)
-            type = this.language().types.makeOpenArray(type);
+            type = new (this.language().types.OpenArray)(type);
         this.parent().setType(type);
 
     },
@@ -511,7 +511,7 @@ exports.FormalParameters = ChainedContext.extend({
         var name = parent.typeName();
         if (name === undefined)
             name = "";
-        this.__type = new Procedure.make(name);
+        this.__type = new Procedure.Type(name);
         parent.setType(this.__type);
     },
     handleMessage: function(msg){
@@ -584,9 +584,9 @@ exports.ProcDecl = ChainedContext.extend({
     },
     typeName: function(){return undefined;},
     setType: function(type){
-        var procSymbol = Symbol.makeSymbol(
+        var procSymbol = new Symbol.Symbol(
             this.__id.id(), 
-            Type.makeProcedure(type));
+            new Type.ProcedureId(type));
         this.__outerScope.addSymbol(procSymbol, this.__id.exported());
         this.__type = type;
     },
@@ -594,7 +594,7 @@ exports.ProcDecl = ChainedContext.extend({
         if (name == this.__id.id())
             throw new Errors.Error("argument '" + name + "' has the same name as procedure");
         var v = this._makeArgumentVariable(arg);
-        var s = Symbol.makeSymbol(name, v);
+        var s = new Symbol.Symbol(name, v);
         this.currentScope().addSymbol(s);
 
         var code = this.codeGenerator();
@@ -672,7 +672,7 @@ exports.ProcParams = HandleSymbolAsType.extend({
         for(var i = 0; i < names.length; ++i){
             var name = names[i];
             this.handleMessage(
-                new AddArgumentMsg(name, Type.makeProcedureArgument(type, this.__isVar)));
+                new AddArgumentMsg(name, new Type.ProcedureArgument(type, this.__isVar)));
         }
         this.__isVar = false;
         this.__argNamesForType = [];
@@ -710,11 +710,11 @@ exports.PointerDecl = ChainedContext.extend({
         var name = parent.isAnonymousDeclaration() 
             ? ""
             : parent.genTypeName();
-        var pointerType = Type.makePointer(name, typeId);
+        var pointerType = new Type.Pointer(name, typeId);
         parent.setType(pointerType);
     },
     setType: function(type){
-        var typeId = Type.makeTypeId(type);
+        var typeId = new Type.TypeId(type);
         this.currentScope().addFinalizer(function(){typeId.strip();});
         this.__setTypeId(typeId);
     },
@@ -756,7 +756,7 @@ exports.ArrayDecl = HandleSymbolAsType.extend({
         return rtl.makeArray(dimensions + ", " + initializer);
     },
     _makeType: function(elementsType, init, length){
-        return this.language().types.makeStaticArray(init, elementsType, length);
+        return new (this.language().types.StaticArray)(init, elementsType, length);
     }
 });
 
@@ -1584,8 +1584,8 @@ exports.ConstDecl = ChainedContext.extend({
         this.__value = value;
     },
     endParse: function(){
-        var c = Type.makeConst(this.__type, this.__value);
-        this.currentScope().addSymbol(Symbol.makeSymbol(this.__id.id(), c), this.__id.exported());
+        var c = new Type.Const(this.__type, this.__value);
+        this.currentScope().addSymbol(new Symbol.Symbol(this.__id.id(), c), this.__id.exported());
         this.codeGenerator().write(";\n");
     }
 });
@@ -1632,7 +1632,7 @@ exports.VariableDeclaration = HandleSymbolAsType.extend({
             var varName = id.id();
             if (id.exported())
                 this.checkExport(varName);
-            this.currentScope().addSymbol(Symbol.makeSymbol(varName, v), id.exported());
+            this.currentScope().addSymbol(new Symbol.Symbol(varName, v), id.exported());
             gen.write("var " + varName + " = " + this._initCode() + ";");
         }
 
@@ -1709,12 +1709,12 @@ function isTypeRecursive(type, base){
 }
 
 exports.RecordDecl = ChainedContext.extend({
-    init: function RecordDeclContext(context, makeRecord){
+    init: function RecordDeclContext(context, RecordCons){
         ChainedContext.prototype.init.call(this, context);
         var parent = this.parent();
         this.__cons = parent.genTypeName();
         var name = parent.isAnonymousDeclaration() ? "" : this.__cons;
-        this.__type = makeRecord(name, this.__cons, context.currentScope());
+        this.__type = new RecordCons(name, this.__cons, context.currentScope());
         parent.setType(this.__type);
     },
     type: function(){return this.__type;},
@@ -1783,7 +1783,7 @@ exports.RecordDecl = ChainedContext.extend({
         return this.language().rtl.extend(this.__cons, qualifiedBase) + ";\n";
     },
     _makeField: function(field, type){
-        return Type.makeRecordField(field, type);
+        return new Type.RecordField(field, type);
     }
 });
 
@@ -1794,8 +1794,8 @@ exports.TypeDeclaration = ChainedContext.extend({
         this.__symbol = undefined;
     },
     handleIdentdef: function(id){
-        var typeId = Type.makeLazyTypeId();
-        var symbol = Symbol.makeSymbol(id.id(), typeId);
+        var typeId = new Type.LazyTypeId();
+        var symbol = new Symbol.Symbol(id.id(), typeId);
         this.currentScope().addSymbol(symbol, id.exported());
         if (!id.exported())
             this.currentScope().addFinalizer(function(){typeId.strip();});
@@ -1826,7 +1826,7 @@ exports.TypeSection = ChainedContext.extend({
             Scope.addUnresolved(scope, msg.id);
             var resolve = function(){return getSymbol(this, msg.id).info().type();}.bind(this);
 
-            return Type.makeForwardTypeId(resolve);
+            return new Type.ForwardTypeId(resolve);
         }
         return ChainedContext.prototype.handleMessage.call(this, msg);
     },
@@ -1870,7 +1870,7 @@ exports.ModuleDeclaration = ChainedContext.extend({
         var parent = this.parent();
         if (this.__name === undefined ) {
             this.__name = id;
-            this.__moduleScope = Scope.makeModule(id, this.__stdSymbols);
+            this.__moduleScope = new Scope.Module(id, this.__stdSymbols);
             parent.pushScope(this.__moduleScope);
         }
         else if (id === this.__name){
@@ -1946,7 +1946,7 @@ var ModuleImport = ChainedContext.extend({
             if (!module)
                 unresolved.push(moduleName);
             else
-                modules.push(Symbol.makeSymbol(alias, module));
+                modules.push(new Symbol.Symbol(alias, module));
         }
         if (unresolved.length)
             throw new Errors.Error("module(s) not found: " + unresolved.join(", "));

src/eberon/EberonArray.ob

@@ -7,21 +7,25 @@ TYPE
     END;
     PMethod* = POINTER TO Method;
 
-    MethodField = RECORD(Types.Field)
+    MethodField* = RECORD(Types.Field)
+        PROCEDURE MethodField*(method: PMethod);
+
         method: PMethod
     END;
 
     MethodIndexOf = RECORD(Method)
+        PROCEDURE MethodIndexOf(elementsType: Types.PType);
+
         elementsType: Types.PType
     END;
 
     MethodCallIndexOf = RECORD(Procedure.StdCall)
     END;
 
-    StaticArray = RECORD(Types.StaticArray)
+    StaticArray* = RECORD(Types.StaticArray)
     END;
 
-    OpenArray = RECORD(Types.OpenArray)
+    OpenArray* = RECORD(Types.OpenArray)
     END;
 
 PROCEDURE Method.description(): STRING;
@@ -44,30 +48,20 @@ PROCEDURE MethodField.asVar(isReadOnly: BOOLEAN; cx: Context.Type): Types.PId;
     RETURN EberonTypes.makeMethod(SELF.method)
 END MethodField.asVar;
 
-PROCEDURE makeIndexOfMethod(elementsType: Types.PType): PMethod;
-VAR
-    result: POINTER TO MethodIndexOf;
+PROCEDURE MethodIndexOf.MethodIndexOf(elementsType: Types.PType)
+    | SUPER(methodNameIndexOf, NIL),
+      elementsType(elementsType);
 BEGIN
-    NEW(result);
-    result.name := methodNameIndexOf;
-    result.elementsType := elementsType;
-    RETURN result
-END makeIndexOfMethod;
+END;
 
 PROCEDURE MethodIndexOf.designatorCode(id: STRING): STRING;
     RETURN "indexOf"
 END MethodIndexOf.designatorCode;
 
 PROCEDURE MethodIndexOf.callGenerator(cx: LanguageContext.PType): Procedure.PCallGenerator;
-VAR
-    a: Types.PProcedureArgument;
-    call: POINTER TO MethodCallIndexOf;
 BEGIN
-    NEW(call);
-    Procedure.initStdCall(call);
-
-    NEW(a);
-    a.type := SELF.elementsType;
+    call <- NEW MethodCallIndexOf();
+    a <- NEW Types.ProcedureArgument(SELF.elementsType, FALSE);
     call.args.add(a);
     RETURN Procedure.makeCallGenerator(call, cx)
 END MethodIndexOf.callGenerator;
@@ -84,19 +78,14 @@ VAR
     result: PMethod;
 BEGIN
     IF id = methodNameIndexOf THEN
-        result := makeIndexOfMethod(elementsType);
+        result := NEW MethodIndexOf(elementsType);
     END;
     RETURN result
 END denoteMethod;
 
-PROCEDURE makeMethodField*(method: PMethod): Types.PField;
-VAR
-    result: POINTER TO MethodField;
-BEGIN
-    NEW(result);
-    result.method := method;
-    RETURN result
-END makeMethodField;
+PROCEDURE MethodField.MethodField(method: PMethod)
+    | method(method);
+END;
 
 PROCEDURE denote(id: STRING; a: Types.Array): Types.PField;
 VAR
@@ -106,7 +95,7 @@ BEGIN
         IF (a.elementsType IS Types.PRecord) OR (a.elementsType IS Types.PArray) THEN
             Errors.raise("'" + methodNameIndexOf + "' is not defined for array of '" + a.elementsType.description() + "'");
         END;
-        result := makeMethodField(makeIndexOfMethod(a.elementsType));
+        result := NEW MethodField(NEW MethodIndexOf(a.elementsType));
     END;
     RETURN result
 END denote;
@@ -129,26 +118,4 @@ BEGIN
     RETURN result
 END OpenArray.denote;
 
-PROCEDURE makeStaticArray*(
-    initializer: STRING;
-    elementsType: Types.PType;
-    len: INTEGER
-    ): Types.PArray;
-VAR
-    result: POINTER TO StaticArray;
-BEGIN
-    NEW(result);
-    Types.initStaticArray(initializer, elementsType, len, result^);
-    RETURN result
-END makeStaticArray;
-
-PROCEDURE makeOpenArray*(elementsType: Types.PType): Types.PArray;
-VAR
-    result: POINTER TO OpenArray;
-BEGIN
-    NEW(result);
-    Types.initArray(elementsType, result^);
-    RETURN result
-END makeOpenArray;
-
 END EberonArray.

src/eberon/EberonConstructor.ob

@@ -59,7 +59,6 @@ PROCEDURE makeCallGenerator(
     call: PConstructorCall
     ): Procedure.PCallGenerator;
 BEGIN
-    Procedure.initStdCall(call);
     call.recordType := recordType; 
     call.resultType := resultType;
     cons <- EberonRecord.constructor(recordType^);
@@ -82,7 +81,7 @@ BEGIN
 
     variable <- Types.makeVariable(SELF.type, FALSE);
     lval <- fieldInitLval(SELF.field, SELF.type);
-    designator <- Code.makeDesignator(SELF.field, lval, NIL, SELF.type, variable, NIL);
+    designator <- NEW Code.Designator(SELF.field, lval, NIL, SELF.type, variable, NIL);
     left <- Code.makeExpression(SELF.field, SELF.type, designator, NIL);
     SELF.code := Operator.assign(left, e, SELF.cx^);    
 END;
@@ -100,10 +99,8 @@ PROCEDURE makeConstructorCall*(
     cx: LanguageContext.PType;
     forNew: BOOLEAN
     ): Procedure.PCallGenerator;
-VAR
-    call: PConstructorCall;
 BEGIN
-    NEW(call);
+    call <- NEW ConstructorCall();
     resultType <- typeId.type();
     recordType <- resultType(EberonRecord.PRecord); 
     
@@ -114,7 +111,7 @@ BEGIN
     
     EberonRecord.ensureCanBeInstantiated(cx^, recordType, instType);
     IF forNew THEN
-        resultType := Types.makePointer("", typeId);
+        resultType := NEW Types.Pointer("", typeId);
     END;
     RETURN makeCallGenerator(recordType, resultType, cx, call);
 END;
@@ -128,19 +125,15 @@ VAR
     result: Procedure.PCallGenerator;
 
     PROCEDURE initRecord(type: EberonRecord.PRecord): Procedure.PCallGenerator;
-    VAR
-        call: POINTER TO RecordInitCall;
     BEGIN
-        NEW(call);
+        call <- NEW RecordInitCall();
         call.field := field;
         RETURN makeCallGenerator(type, type, cx, call);
     END;
 
     PROCEDURE initNonRecord(): Procedure.PCallGenerator;
-    VAR
-        result: POINTER TO NonRecordInitCall;
     BEGIN
-        NEW(result);
+        result <- NEW NonRecordInitCall();
         result.cx := cx;
         result.field := field;
         result.type := type;
@@ -159,11 +152,7 @@ PROCEDURE makeBaseConstructorCall*(
     type: EberonRecord.PRecord; 
     cx: LanguageContext.PType
     ): Procedure.PCallGenerator;
-VAR
-    call: POINTER TO BaseConstructorCall;
-BEGIN
-    NEW(call);
-    RETURN makeCallGenerator(type, type, cx, call);
+    RETURN makeCallGenerator(type, type, cx, NEW BaseConstructorCall());
 END;
 
 END EberonConstructor.

src/eberon/EberonContext.ob

@@ -2,6 +2,8 @@ MODULE EberonContext;
 IMPORT Context;
 TYPE
     IdentdefInfo* = RECORD(Context.IdentdefInfo)
+        PROCEDURE IdentdefInfo(id: STRING; exported: BOOLEAN; ro: BOOLEAN);
+
         PROCEDURE isReadOnly*(): BOOLEAN;
         
         ro: BOOLEAN;
@@ -12,14 +14,9 @@ PROCEDURE IdentdefInfo.isReadOnly(): BOOLEAN;
     RETURN SELF.ro;
 END;
 
-PROCEDURE makeIdentdefInfo*(id: STRING; exported: BOOLEAN; ro: BOOLEAN): PIdentdefInfo;
-VAR
-    result: PIdentdefInfo;
-BEGIN
-    NEW(result);
-    Context.initIdentdefInfo(id, exported, result^);
-    result.ro := ro;
-    RETURN result;
+PROCEDURE IdentdefInfo.IdentdefInfo(id: STRING; exported: BOOLEAN; ro: BOOLEAN)
+    | SUPER(id, exported),
+      ro(ro);
 END;
 
 END EberonContext.

src/eberon/EberonDynamicArray.ob

@@ -19,6 +19,8 @@ TYPE
     END;
 
     MethodAdd = RECORD(Method)
+    PROCEDURE MethodAdd(elementsType: Types.PType);
+
         elementsType: Types.PType
     END;
 
@@ -54,33 +56,10 @@ PROCEDURE DynamicArray.description(): STRING;
     RETURN Types.arrayDescription(SELF, arrayDimensionDescription)
 END DynamicArray.description;
 
-PROCEDURE makeAddField(elementsType: Types.PType): EberonArray.PMethod;
-VAR
-    result: POINTER TO MethodAdd;
-BEGIN
-    NEW(result);
-    result.name := methodNameAdd;
-    result.elementsType := elementsType;
-    RETURN result
-END makeAddField;
-
-PROCEDURE makeClearMethod(): EberonArray.PMethod;
-VAR
-    result: POINTER TO MethodClear;
-BEGIN
-    NEW(result);
-    result.name := methodNameClear;
-    RETURN result
-END makeClearMethod;
-
-PROCEDURE makeRemoveMethod(): EberonArray.PMethod;
-VAR
-    result: POINTER TO MethodRemove;
-BEGIN
-    NEW(result);
-    result.name := methodNameRemove;
-    RETURN result
-END makeRemoveMethod;
+PROCEDURE MethodAdd.MethodAdd(elementsType: Types.PType)
+    | SUPER(methodNameAdd, NIL),
+      elementsType(elementsType);
+END;
 
 PROCEDURE DynamicArray.denote(id: STRING): Types.PField;
 VAR
@@ -88,31 +67,22 @@ VAR
     result: Types.PField;
 BEGIN
     IF      id = methodNameAdd THEN
-        method := makeAddField(SELF.elementsType);
+        method := NEW MethodAdd(SELF.elementsType);
     ELSIF   id = methodNameClear THEN
-        method := makeClearMethod();
+        method := NEW MethodClear(methodNameClear, NIL);
     ELSIF   id = methodNameRemove THEN
-        method := makeRemoveMethod();
+        method := NEW MethodRemove(methodNameRemove, NIL);
     ELSE
         method := EberonArray.denoteMethod(id, SELF.elementsType);
     END;
     IF method # NIL THEN
-        result := EberonArray.makeMethodField(method);
+        result := NEW EberonArray.MethodField(method);
     ELSE
         result := SUPER(id);
     END;
     RETURN result
 END DynamicArray.denote;
 
-PROCEDURE makeDynamicArray*(elementsType: Types.PType): PDynamicArray;
-VAR
-    result: PDynamicArray;
-BEGIN
-    NEW(result);
-    Types.initArray(elementsType, result^);
-    RETURN result
-END makeDynamicArray;
-
 PROCEDURE AddCallGenerator.handleArgument(e: Code.PExpression);
 BEGIN
     IF SELF.code # "" THEN
@@ -122,7 +92,7 @@ BEGIN
     argCode <- Procedure.makeArgumentsCode(SELF.cx);
     Procedure.checkArgument(
         e, 
-        Types.makeProcedureArgument(SELF.elementsType, FALSE), 
+        NEW Types.ProcedureArgument(SELF.elementsType, FALSE), 
         0, 
         argCode, 
         SELF.cx.types);
@@ -155,10 +125,8 @@ PROCEDURE MethodAdd.designatorCode(id: STRING): STRING;
 END MethodAdd.designatorCode;
 
 PROCEDURE MethodAdd.callGenerator(cx: LanguageContext.PType): Procedure.PCallGenerator;
-VAR
-    result: POINTER TO AddCallGenerator;
 BEGIN
-    NEW(result);
+    result <- NEW AddCallGenerator();
     result.cx := cx;
     result.elementsType := SELF.elementsType;
     RETURN result
@@ -190,25 +158,14 @@ PROCEDURE MethodRemove.designatorCode(id: STRING): STRING;
 END MethodRemove.designatorCode;
 
 PROCEDURE MethodClear.callGenerator(cx: LanguageContext.PType): Procedure.PCallGenerator;
-VAR
-    call: POINTER TO MethodCallClear;
-BEGIN
-    NEW(call);
-    Procedure.initStdCall(call);
-    RETURN Procedure.makeCallGenerator(call, cx)
-END MethodClear.callGenerator;
+    RETURN Procedure.makeCallGenerator(NEW MethodCallClear(), cx)
+END;
 
 PROCEDURE MethodRemove.callGenerator(cx: LanguageContext.PType): Procedure.PCallGenerator
 ;
-VAR
-    a: Types.PProcedureArgument;
-    call: POINTER TO MethodCallRemove;
 BEGIN
-    NEW(call);
-    Procedure.initStdCall(call);
-
-    NEW(a);
-    a.type := Types.basic.integer;
+    call <- NEW MethodCallRemove();
+    a <- NEW Types.ProcedureArgument(Types.basic.integer, FALSE);
     call.args.add(a);
     RETURN Procedure.makeCallGenerator(call, cx)
 END MethodRemove.callGenerator;

src/eberon/EberonRecord.ob

@@ -7,6 +7,8 @@ CONST
     instantiateForCopy* = 2;    
 TYPE
     Record* = RECORD(Types.Record)
+        PROCEDURE Record(name: STRING; cons: STRING; scope: ScopeBase.PType);
+
         PROCEDURE declareConstructor(type: Types.PDefinedProcedure; exported: BOOLEAN);
         PROCEDURE addMethod(methodId: Context.PIdentdefInfo; type: Types.PProcedure);
         PROCEDURE defineConstructor(type: Types.PDefinedProcedure);
@@ -14,7 +16,7 @@ TYPE
         PROCEDURE requireNewOnly();
         PROCEDURE setBaseConstructorCallCode(code: STRING);
         PROCEDURE setFieldInitializationCode(field: STRING; code: STRING);
-        PROCEDURE setRecordInitializationCode(baseConstructorCallCode, inheritanceCode: STRING);
+        PROCEDURE setRecordInitializationCode(baseConstructorCallCode: STRING);
 
         customConstructor-: Types.PDefinedProcedure;
         customConstructorExported: BOOLEAN;
@@ -29,14 +31,16 @@ TYPE
         declaredAsVariable: BOOLEAN;
         lazyDefinitions: JsMap.Type;
         nonExportedMethods: ARRAY * OF STRING;
-        inheritanceCode-, baseConstructorCallCode-: STRING;
+        baseConstructorCallCode-: STRING;
         fieldsInit: JsMap.Strings;
         fieldsInitOrder: ARRAY * OF STRING;
         lastFieldInit: INTEGER;
     END;
     PRecord* = POINTER TO Record;
 
-    RecordField = RECORD(Types.RecordField)
+    RecordField* = RECORD(Types.RecordField)
+        PROCEDURE RecordField*(identdef: Context.PIdentdefInfo; type: Types.PType; record: PRecord);
+
         record: PRecord;
     END;
 
@@ -44,9 +48,10 @@ TYPE
     END;
     PRecordFieldAsMethod = POINTER TO RecordFieldAsMethod;
 
-    MethodIds = POINTER TO RECORD(Object.Type)
+    MethodIds = RECORD(Object.Type)
         ids: ARRAY * OF STRING;
     END;
+    PMethodIds = POINTER TO MethodIds;
 
     EnsureMethodDefinitionsClosure = RECORD(Object.Type)
         record: PRecord;
@@ -107,7 +112,7 @@ PROCEDURE ensureMethodDefinitionsForEach(key: STRING; value: Object.PType; VAR c
         END;
     END;
 BEGIN
-    do(value(MethodIds).ids, closure(EnsureMethodDefinitionsClosure));
+    do(value(PMethodIds).ids, closure(EnsureMethodDefinitionsClosure));
 END;
 
 PROCEDURE ensureMethodDefinitions(r: PRecord; reasons: JsMap.Type);
@@ -121,21 +126,13 @@ BEGIN
     END;
 END;
 
-PROCEDURE makeMethodIds(): MethodIds;
-VAR
-    result: MethodIds;
-BEGIN
-    NEW(result);
-    RETURN result;
-END;
-
 PROCEDURE requireMethodDefinition*(r: PRecord; id: STRING; reason: STRING);
 VAR
     existingIds: Object.PType;
 
-    PROCEDURE makeIds(): MethodIds;
+    PROCEDURE makeIds(): PMethodIds;
     BEGIN
-        result <- makeMethodIds();
+        result <- NEW MethodIds();
         result.ids.add(id);
         RETURN result;
     END;
@@ -160,7 +157,7 @@ BEGIN
         IF ~JsMap.find(r.lazyDefinitions, reason, existingIds) THEN
             JsMap.put(r.lazyDefinitions, reason, makeIds());
         ELSE
-            addIfNotThere(existingIds(MethodIds).ids);
+            addIfNotThere(existingIds(PMethodIds).ids);
         END;
     END;
 END;
@@ -213,15 +210,6 @@ PROCEDURE RecordFieldAsMethod.asVar(isReadOnly: BOOLEAN; cx: Context.Type): Type
     RETURN EberonTypes.makeMethod(SELF.type()); 
 END;
 
-PROCEDURE makeRecordFieldAsMethod(identdef: Context.PIdentdefInfo; type: Types.PType): PRecordFieldAsMethod;
-VAR
-    result: PRecordFieldAsMethod;
-BEGIN
-    NEW(result);
-    Types.initRecordField(identdef, type, result^);
-    RETURN result; 
-END;
-
 PROCEDURE constructor*(r: Record): Types.PDefinedProcedure;
 BEGIN
     result <- r.customConstructor;
@@ -333,7 +321,7 @@ BEGIN
         Errors.raise(msg);
     END;
 
-    JsMap.put(SELF.declaredMethods, id, makeRecordFieldAsMethod(methodId, type));
+    JsMap.put(SELF.declaredMethods, id, NEW RecordFieldAsMethod(methodId, type));
     IF ~methodId.exported() THEN
         SELF.nonExportedMethods.add(id);
     END;
@@ -391,10 +379,9 @@ BEGIN
     JsMap.putString(SELF.fieldsInit, field, code);
 END;
 
-PROCEDURE Record.setRecordInitializationCode(baseConstructorCallCode, inheritanceCode: STRING);
+PROCEDURE Record.setRecordInitializationCode(baseConstructorCallCode: STRING);
 BEGIN
     SELF.baseConstructorCallCode := baseConstructorCallCode;
-    SELF.inheritanceCode := inheritanceCode;
 END;
 
 PROCEDURE Record.declareConstructor(type: Types.PDefinedProcedure; exported: BOOLEAN);
@@ -501,17 +488,12 @@ BEGIN
     RETURN SUPER(actualReadOnly, cx); 
 END;
 
-PROCEDURE makeRecord*(name: STRING; cons: STRING; scope: ScopeBase.PType): Types.PRecord;
-VAR
-    result: PRecord;
-BEGIN
-    NEW(result);
-    Types.initRecord(result, name, cons, scope);
-    result.declaredMethods := JsMap.make();
-    result.lazyDefinitions := JsMap.make();
-    result.fieldsInit := JsMap.makeStrings();
-    result.lastFieldInit := -1;
-    RETURN result;
+PROCEDURE Record.Record(name: STRING; cons: STRING; scope: ScopeBase.PType)
+    | SUPER(name, cons, scope),
+      declaredMethods(JsMap.make()),
+      lazyDefinitions(JsMap.make()),
+      fieldsInit(JsMap.makeStrings()),
+      lastFieldInit(-1);
 END;
 
 PROCEDURE genFieldInitCode(key: STRING; value: Object.PType; VAR closure: Object.Type);
@@ -543,14 +525,10 @@ BEGIN
     RETURN closure.code;
 END;
 
-PROCEDURE makeRecordField*(identdef: Context.PIdentdefInfo; type: Types.PType; record: PRecord): Types.PRecordField;
-VAR
-    result: POINTER TO RecordField;
+PROCEDURE RecordField.RecordField(identdef: Context.PIdentdefInfo; type: Types.PType; record: PRecord)
+    | SUPER(identdef, type);
 BEGIN
-    NEW(result);
-    Types.initRecordField(identdef, type, result^);
-    result.record := record;
-    RETURN result;
+    SELF.record := record;
 END;
 
 END EberonRecord.

src/eberon/EberonScope.ob

@@ -31,13 +31,10 @@ BEGIN
 END Operator.addSymbol;
 
 PROCEDURE makeOperator*(parent: Scope.PType; stdSymbols: JsMap.Type): Scope.PType;
-VAR
-    result: POINTER TO Operator;
 BEGIN
-    NEW(result);
-    Scope.init(result^, stdSymbols);
+    result <- NEW Operator(stdSymbols);
     result.parent := parent;
     RETURN result
-END makeOperator;
+END;
 
 END EberonScope.

src/eberon/EberonString.ob

@@ -23,13 +23,9 @@ PROCEDURE ElementVariable.isReference(): BOOLEAN;
 END ElementVariable.isReference;
 
 PROCEDURE makeElementVariable*(): Types.PVariable;
-VAR
-    result: POINTER TO ElementVariable;
-BEGIN
-    NEW(result);
-    RETURN result
-END makeElementVariable;
+    RETURN NEW ElementVariable();
+END;
 
 BEGIN
-    string := Types.makeBasic("STRING", "''");
+    string := NEW Types.BasicType("STRING", "''");
 END EberonString.

src/eberon/EberonTypes.ob

@@ -5,6 +5,8 @@ TYPE
     CallGenerator = PROCEDURE(cx: LanguageContext.PType; type: Types.DefinedProcedure): Procedure.PCallGenerator;
 
     MethodType* = RECORD(Procedure.Std)
+        PROCEDURE MethodType*(id: STRING; t: Types.PDefinedProcedure; call: CallGenerator);
+
         PROCEDURE procType*(): Types.PDefinedProcedure;
 
         type: Types.PDefinedProcedure;
@@ -31,28 +33,19 @@ PROCEDURE MethodType.callGenerator(cx: LanguageContext.PType): Procedure.PCallGe
     RETURN SELF.call(cx, SELF.type^)
 END MethodType.callGenerator;
 
-PROCEDURE makeMethodType*(id: STRING; t: Types.PDefinedProcedure; call: CallGenerator): PMethodType;
-VAR
-    result: PMethodType;
+PROCEDURE MethodType.MethodType(id: STRING; t: Types.PDefinedProcedure; call: CallGenerator)
+    | SUPER(id, NIL);
 BEGIN
-    NEW(result);
-    result.name := id;
-    result.type := t;
-    result.call := call;
-    RETURN result
-END makeMethodType;
+    SELF.type := t;
+    SELF.call := call;
+END;
 
 PROCEDURE MethodVariable.idType(): STRING;
     RETURN "method"
 END MethodVariable.idType;
 
 PROCEDURE makeMethod*(type: Types.PType): Types.PProcedureId;
-VAR
-    result: POINTER TO MethodVariable;
-BEGIN
-    NEW(result);
-    result.type := type;
-    RETURN result
-END makeMethod;
+    RETURN NEW MethodVariable(type);
+END;
 
 END EberonTypes.

src/eberon/eberon_context.js

@@ -162,7 +162,7 @@ var Identdef = Context.Identdef.extend({
         Context.Identdef.prototype.handleLiteral.call(this, l);
     },
     _makeIdendef: function(){
-        return EberonContext.makeIdentdefInfo(this._id, this._export, this.__ro);
+        return new EberonContext.IdentdefInfo(this._id, this._export, this.__ro);
     }
 });
 
@@ -229,8 +229,8 @@ var Designator = Context.Designator.extend({
             this._advance(type, type, "this");
         } 
         else if (s == "POINTER"){
-            var typeId = Type.makeTypeId(this.handleMessage(getSelfAsPointerMsg));
-            var pointerType = Type.makePointer("", typeId);
+            var typeId = new Type.TypeId(this.handleMessage(getSelfAsPointerMsg));
+            var pointerType = new Type.Pointer("", typeId);
             var info = Type.makeVariable(pointerType, true);
             this._advance(pointerType, info, "");
         }
@@ -322,7 +322,7 @@ var InPlaceVariableInit = Context.Chained.extend({
             throw new Errors.Error("cannot use " + type.description() + " to initialize variable");
         var v = isString ? new InPlaceStringLiteral(type) 
                          : new TypeNarrowVariable(type, false, false);
-        this._symbol = Symbol.makeSymbol(this.__id, v);
+        this._symbol = new Symbol.Symbol(this.__id, v);
         if (type instanceof Type.Record){
             EberonRecord.ensureCanBeInstantiated(this, type, EberonRecord.instantiateForCopy);
             if (e.designator())
@@ -369,7 +369,7 @@ var ExpressionProcedureCall = Context.Chained.extend({
         var parent = this.parent();
         if (info instanceof ResultVariable){
             var e = info.expression();
-            parent.handleExpression(Code.makeExpressionWithPrecedence(d.code(), d.type(), undefined, e.constValue(), e.maxPrecedence()));
+            parent.handleExpression(new Code.Expression(d.code(), d.type(), undefined, e.constValue(), e.maxPrecedence()));
         }
         else
             parent.setDesignator(d);
@@ -462,7 +462,7 @@ var TypeDeclaration = Context.TypeDeclaration.extend({
 
 var RecordDecl = Context.RecordDecl.extend({
     init: function EberonContext$RecordDecl(context){
-        Context.RecordDecl.prototype.init.call(this, context, EberonRecord.makeRecord);
+        Context.RecordDecl.prototype.init.call(this, context, EberonRecord.Record);
     },
     handleMessage: function(msg){
         if (msg instanceof MethodOrProcMsg){
@@ -479,7 +479,7 @@ var RecordDecl = Context.RecordDecl.extend({
             }
             else
                 boundType.addMethod(msg.id,
-                                    EberonTypes.makeMethodType(id, methodType, Procedure.makeProcCallGenerator));
+                                    new EberonTypes.MethodType(id, methodType, Procedure.makeProcCallGenerator));
             return;
         }
 
@@ -490,7 +490,7 @@ var RecordDecl = Context.RecordDecl.extend({
         return Context.RecordDecl.prototype.handleMessage.call(this, msg);
     },
     _makeField: function(field, type){
-        return EberonRecord.makeRecordField(field, type, this.__type);
+        return new EberonRecord.RecordField(field, type, this.__type);
     },
     _generateBaseConstructorCallCode: function(){
         var base = Type.recordBase(this.type());
@@ -669,7 +669,7 @@ var ProcOrMethodDecl = Context.ProcDecl.extend({
     },
     setType: function(type){
         if (this.__methodId){
-            this.__methodType = EberonTypes.makeMethodType(this.__methodId.id(), type, Procedure.makeProcCallGenerator);
+            this.__methodType = new EberonTypes.MethodType(this.__methodId.id(), type, Procedure.makeProcCallGenerator);
             this.__type = type;
             }            
         else
@@ -727,7 +727,7 @@ var ProcOrMethodDecl = Context.ProcDecl.extend({
         
         return {
             info: this.__isConstructor ? undefined
-                                       : Type.makeProcedure(EberonTypes.makeMethodType(id, this.__methodType.procType(), superMethodCallGenerator)),
+                                       : new Type.ProcedureId(new EberonTypes.MethodType(id, this.__methodType.procType(), superMethodCallGenerator)),
             code: this.qualifyScope(Type.recordScope(baseType))
                 + Type.typeName(baseType) + ".prototype." + id + ".call"
         };
@@ -1161,7 +1161,7 @@ var ArrayDecl = Context.ArrayDecl.extend({
     },
     _makeType: function(elementsType, init, length){
         return length == dynamicArrayLength
-            ? EberonDynamicArray.makeDynamicArray(elementsType)
+            ? new EberonDynamicArray.DynamicArray(elementsType)
             : Context.ArrayDecl.prototype._makeType.call(this, elementsType, init, length);
     }
 });
@@ -1203,9 +1203,10 @@ var FormalType = Context.HandleSymbolAsType.extend({
     },
     setType: function(type){           
         for(var i = this.__arrayDimensions.length; i--;){
-            type = this.__arrayDimensions[i] 
-                ? EberonDynamicArray.makeDynamicArray(type)
-                : this.language().types.makeOpenArray(type);
+            var Cons = this.__arrayDimensions[i]
+                ? EberonDynamicArray.DynamicArray
+                : this.language().types.OpenArray;
+            type = new Cons(type);
         }
         this.parent().setType(type);
     },

src/eberon/eberon_grammar.js

@@ -146,8 +146,8 @@ exports.language = {
     stdSymbols: Symbols.makeStd(),
     types: {
         implicitCast: Cast.implicit,
-        makeStaticArray: EbArray.makeStaticArray,
-        makeOpenArray: EbArray.makeOpenArray
+        StaticArray: EbArray.StaticArray,
+        OpenArray: EbArray.OpenArray
     },
     codeGenerator: {
         make: CodeGenerator.makeGenerator,

src/ob/Code.ob

@@ -15,6 +15,8 @@ TYPE
     RefCodeProc = PROCEDURE(s: STRING): STRING;
 
     Designator* = RECORD
+        PROCEDURE Designator*(code: STRING; lval: STRING; refCode: RefCodeProc; type: Types.PType; info: Types.PId; scope: ScopeBase.PType);
+
         PROCEDURE code(): STRING;
         PROCEDURE lval(): STRING;
         PROCEDURE refCode(): RefCodeProc;
@@ -53,6 +55,13 @@ TYPE
     END;
 
     Expression* = RECORD(Object.Type)
+        PROCEDURE Expression*(
+            code: STRING; 
+            type: Types.PType; 
+            designator: PDesignator; 
+            constValue: PConst; 
+            maxPrecedence: INTEGER);
+
         PROCEDURE code*(): STRING;
         PROCEDURE lval*(): STRING;
         PROCEDURE type*(): Types.PType;
@@ -70,7 +79,9 @@ TYPE
 
     PExpression* = POINTER TO Expression;
 
-    ModuleGenerator = RECORD
+    ModuleGenerator* = RECORD
+        PROCEDURE ModuleGenerator*(name: STRING; imports: JsMap.Strings);
+
         PROCEDURE prolog(): STRING;
         PROCEDURE epilog(exports: JsMap.Type): STRING;
 
@@ -121,58 +132,45 @@ PROCEDURE Expression.isTerm(): BOOLEAN;
 END Expression.isTerm;
 
 PROCEDURE makeIntConst*(n: INTEGER): PConst;
-VAR
-    result: POINTER TO IntConst;
 BEGIN
-    NEW(result);
+    result <- NEW IntConst();
     result.value := n;
     RETURN result
-END makeIntConst;
+END;
 
 PROCEDURE makeRealConst*(n: REAL): PConst;
-VAR
-    result: POINTER TO RealConst;
 BEGIN
-    NEW(result);
+    result <- NEW RealConst();
     result.value := n;
     RETURN result
-END makeRealConst;
+END;
 
 PROCEDURE makeSetConst*(s: SET): PConst;
-VAR
-    result: POINTER TO SetConst;
 BEGIN
-    NEW(result);
+    result <- NEW SetConst();
     result.value := s;
     RETURN result
-END makeSetConst;
+END;
 
 PROCEDURE makeStringConst*(s: STRING): PConst;
-VAR
-    result: POINTER TO StringConst;
 BEGIN
-    NEW(result);
+    result <- NEW StringConst();
     result.value := s;
     RETURN result
-END makeStringConst;
+END;
 
-PROCEDURE makeExpressionWithPrecedence*(
+PROCEDURE Expression.Expression(
     code: STRING; 
     type: Types.PType; 
     designator: PDesignator; 
     constValue: PConst; 
-    maxPrecedence: INTEGER): PExpression;
-VAR
-    result: PExpression;
-BEGIN
-    NEW(result);
-    result.mCode := code;
-    result.mType := type;
-    result.mDesignator := designator;
-    result.mConstValue := constValue;
-    result.mMaxPrecedence := maxPrecedence;
-    RETURN result
-END makeExpressionWithPrecedence;
+    maxPrecedence: INTEGER)
+  | mCode(code),
+    mType(type),
+    mDesignator(designator),
+    mConstValue(constValue),
+    mMaxPrecedence(maxPrecedence);
+END;
 
 PROCEDURE makeExpression*(
     code: STRING; 
@@ -180,7 +178,7 @@ PROCEDURE makeExpression*(
     designator: PDesignator; 
     constValue: PConst)
     : PExpression;
-    RETURN makeExpressionWithPrecedence(code, type, designator, constValue, Precedence.none)
+    RETURN NEW Expression(code, type, designator, constValue, Precedence.none)
 END makeExpression;
 
 PROCEDURE makeSimpleExpression*(
@@ -214,19 +212,14 @@ PROCEDURE Designator.scope(): ScopeBase.PType;
     RETURN SELF.mScope
 END Designator.scope;
 
-PROCEDURE makeDesignator*(code: STRING; lval: STRING; refCode: RefCodeProc; type: Types.PType; info: Types.PId; scope: ScopeBase.PType): PDesignator;
-VAR
-    result: PDesignator;
-BEGIN
-    NEW(result);
-    result.mCode := code;
-    result.mLval := lval;
-    result.mRefCode := refCode;
-    result.mType := type;
-    result.mInfo := info;
-    result.mScope := scope;
-    RETURN result
-END makeDesignator;
+PROCEDURE Designator.Designator(code: STRING; lval: STRING; refCode: RefCodeProc; type: Types.PType; info: Types.PId; scope: ScopeBase.PType)
+  | mCode(code),
+    mLval(lval),
+    mRefCode(refCode),
+    mType(type),
+    mInfo(info),
+    mScope(scope);
+END;
 
 PROCEDURE derefExpression*(e: PExpression): PExpression;
 VAR
@@ -371,15 +364,10 @@ BEGIN
     RETURN result
 END ModuleGenerator.epilog;
 
-PROCEDURE makeModuleGenerator*(name: STRING; imports: JsMap.Strings): PModuleGenerator;
-VAR
-    result: PModuleGenerator;
-BEGIN
-    NEW(result);
-    result.name := name;
-    result.imports := imports;
-    RETURN result
-END makeModuleGenerator;
+PROCEDURE ModuleGenerator.ModuleGenerator(name: STRING; imports: JsMap.Strings)
+    | name(name),
+      imports(imports);
+END;
 
 PROCEDURE checkIndex*(i: INTEGER);
 BEGIN

src/ob/CodeGenerator.ob

@@ -118,19 +118,11 @@ PROCEDURE Generator.result(): STRING;
 END;
 
 PROCEDURE makeSimpleGenerator*(): PIGenerator;
-VAR
-    result: POINTER TO SimpleGenerator;
-BEGIN
-    NEW(result);
-    RETURN result
-END makeSimpleGenerator;
+    RETURN NEW SimpleGenerator();
+END;
 
 PROCEDURE makeGenerator*(): PIGenerator;
-VAR
-    result: POINTER TO Generator;
-BEGIN
-    NEW(result);
-    RETURN result
+    RETURN NEW Generator();
 END;
 
 END CodeGenerator.

src/ob/Context.ob

@@ -14,6 +14,8 @@ TYPE
     PType* = POINTER TO Type;
 
     IdentdefInfo* = RECORD
+        PROCEDURE IdentdefInfo*(id: STRING; exported: BOOLEAN);
+
         PROCEDURE id*(): STRING;
         PROCEDURE exported*(): BOOLEAN;
 
@@ -31,19 +33,8 @@ PROCEDURE IdentdefInfo.exported(): BOOLEAN;
     RETURN SELF.mExported;
 END;
 
-PROCEDURE initIdentdefInfo*(id: STRING; exported: BOOLEAN; VAR result: IdentdefInfo);
-BEGIN
-    result.mId := id;
-    result.mExported := exported;
-END;
-
-PROCEDURE makeIdentdefInfo*(id: STRING; exported: BOOLEAN): PIdentdefInfo;
-VAR
-    result: PIdentdefInfo;
-BEGIN
-    NEW(result);
-    initIdentdefInfo(id, exported, result^);
-    RETURN result;
+PROCEDURE IdentdefInfo.IdentdefInfo(id: STRING; exported: BOOLEAN)
+    | mId(id), mExported(exported);
 END;
 
 END Context.

src/ob/Lexer.ob

@@ -17,7 +17,9 @@ CONST
         ;
 
 TYPE
-    Literal = POINTER TO RECORD
+    Literal* = RECORD
+        PROCEDURE Literal*(s: STRING);
+
         s: STRING
     END;
 
@@ -29,7 +31,7 @@ PROCEDURE isLetter(c: CHAR): BOOLEAN;
     RETURN ((c >= "a") & (c <= "z")) OR ((c >= "A") & (c <= "Z"))
 END isLetter;
 
-PROCEDURE digit*(stream: Stream.Type; context: Context.Type): BOOLEAN;
+PROCEDURE digit*(VAR stream: Stream.Type; context: Context.Type): BOOLEAN;
 VAR
     result: BOOLEAN;
     c: CHAR;
@@ -44,7 +46,7 @@ BEGIN
     RETURN result
 END digit;
 
-PROCEDURE hexDigit*(stream: Stream.Type; context: Context.Type): BOOLEAN;
+PROCEDURE hexDigit*(VAR stream: Stream.Type; context: Context.Type): BOOLEAN;
 VAR
     result: BOOLEAN;
     c: CHAR;
@@ -64,7 +66,7 @@ BEGIN
     RETURN result
 END handleLiteral;
 
-PROCEDURE point*(stream: Stream.Type; context: Context.Type): BOOLEAN;
+PROCEDURE point*(VAR stream: Stream.Type; context: Context.Type): BOOLEAN;
 VAR result: BOOLEAN;
 BEGIN
     IF    ~Stream.eof(stream)
@@ -76,7 +78,7 @@ BEGIN
     RETURN result
 END point;
 
-PROCEDURE string*(stream: Stream.Type; context: Context.Type): BOOLEAN;
+PROCEDURE string*(VAR stream: Stream.Type; context: Context.Type): BOOLEAN;
 VAR
     result: BOOLEAN;
     c: CHAR;
@@ -124,7 +126,7 @@ BEGIN
     RETURN i = LEN(s)
 END isReservedWord;
 
-PROCEDURE ident*(stream: Stream.Type; context: Context.Type; reservedWords: STRING): BOOLEAN;
+PROCEDURE ident*(VAR stream: Stream.Type; context: Context.Type; reservedWords: STRING): BOOLEAN;
 VAR
     result: BOOLEAN;
     c: CHAR;
@@ -155,7 +157,7 @@ BEGIN
     RETURN result
 END ident;
 
-PROCEDURE skipComment(stream: Stream.Type; context: Context.Type): BOOLEAN;
+PROCEDURE skipComment(VAR stream: Stream.Type; context: Context.Type): BOOLEAN;
 VAR
     result: BOOLEAN;
 BEGIN
@@ -183,7 +185,7 @@ PROCEDURE readSpaces(c: CHAR): BOOLEAN;
         OR (c = 0DX)
 END readSpaces;
 
-PROCEDURE skipSpaces*(stream: Stream.Type; context: Context.Type);
+PROCEDURE skipSpaces*(VAR stream: Stream.Type; context: Context.Type);
 BEGIN
     IF (context.isLexem = NIL) OR ~context.isLexem() THEN
         WHILE Stream.read(stream, readSpaces)
@@ -195,16 +197,11 @@ PROCEDURE separator*(stream: Stream.Type; context: Context.Type): BOOLEAN;
     RETURN Stream.eof(stream) OR ~isLetter(Stream.peekChar(stream))
 END separator;
 
-PROCEDURE makeLiteral*(s: STRING): Literal;
-VAR
-    result: Literal;
-BEGIN
-    NEW(result);
-    JS.do("result.s = s");
-    RETURN result
-END makeLiteral;
+PROCEDURE Literal.Literal(s: STRING)
+    | s(s);
+END;
 
-PROCEDURE literal*(l: Literal; stream: Stream.Type; context: Context.Type): BOOLEAN;
+PROCEDURE literal*(l: Literal; VAR stream: Stream.Type; context: Context.Type): BOOLEAN;
 VAR
     result: BOOLEAN;
 BEGIN

src/ob/Module.ob

@@ -7,6 +7,8 @@ TYPE
     PType* = POINTER TO Type;
 
     AnyType* = RECORD(Types.StorageType)
+        PROCEDURE AnyType();
+
         PROCEDURE callGenerator(cx: LanguageContext.PType): Procedure.PCallGenerator;
         PROCEDURE denote(id: STRING): Types.PField;
         PROCEDURE designatorCode(id: STRING): STRING;
@@ -40,11 +42,7 @@ PROCEDURE AnyType.initializer(cx: Context.Type): STRING;
 END;
 
 PROCEDURE makeCallGenerator(cx: LanguageContext.PType): Procedure.PCallGenerator;
-VAR
-    call: POINTER TO AnyProcCall;
-BEGIN
-    NEW(call);
-    RETURN Procedure.makeCallGenerator(call, cx)
+    RETURN Procedure.makeCallGenerator(NEW AnyProcCall(), cx)
 END makeCallGenerator;
 
 PROCEDURE AnyType.callGenerator(cx: LanguageContext.PType): Procedure.PCallGenerator;
@@ -97,13 +95,13 @@ BEGIN
     ELSIF id = varTypeId THEN
         result := varTypeSymbol;
     ELSE
-        result := Symbols.makeSymbol(id, Types.makeProcedure(any));
+        result := NEW Symbols.Symbol(id, NEW Types.ProcedureId(any));
     END;
-    RETURN Symbols.makeFound(result, NIL)
+    RETURN NEW Symbols.FoundSymbol(result, NIL)
 END JS.findSymbol;
 
 PROCEDURE makeVarTypeSymbol(): Symbols.PSymbol;
-    RETURN Symbols.makeSymbol(varTypeId, Types.makeTypeId(any))
+    RETURN NEW Symbols.Symbol(varTypeId, NEW Types.TypeId(any))
 END makeVarTypeSymbol;
 
 PROCEDURE makeDoProcSymbol(): Symbols.PSymbol;
@@ -114,8 +112,6 @@ TYPE
     END;
 VAR
     description: STRING;
-    call: POINTER TO Call;
-    proc: POINTER TO Proc;
 
     PROCEDURE Call.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     VAR
@@ -136,31 +132,26 @@ VAR
     END Proc.description;
 BEGIN
     description := "JS predefined procedure 'do'";
-    NEW(call);
-    Procedure.initStdCall(call);
+    call <- NEW Call();
     Procedure.hasArgumentWithCustomType(call);
 
-    NEW(proc);
-    Procedure.initStd("", call, proc^);
-    RETURN Procedure.makeSymbol(proc)
+    RETURN Procedure.makeSymbol(NEW Procedure.Std("", call))
 END makeDoProcSymbol;
 
 PROCEDURE makeJS*(): PType;
-VAR
-    result: POINTER TO JS;
-BEGIN
-    NEW(result);
-    Types.initModule(result^, "this");
-    RETURN result
-END makeJS;
+    RETURN NEW JS("this");
+END;
+
+PROCEDURE AnyType.AnyType()
+    | asField(NEW AnyField()),
+      asVar(NEW Types.TypeId(SELF(POINTER)));
+END;
 
 BEGIN
     doProcId := "do$";
     varTypeId := "var$";
     
     NEW(any);
-    NEW(any.asField); 
-    any.asVar := Types.makeTypeId(any);
 
     doProcSymbol := makeDoProcSymbol();
     varTypeSymbol := makeVarTypeSymbol();

src/ob/Operator.ob

@@ -23,6 +23,8 @@ TYPE
     PCodeMaker = POINTER TO CodeMaker;
 
     SimpleCodeMaker = RECORD (CodeMaker)
+        PROCEDURE SimpleCodeMaker(code: STRING);
+
         code: STRING
     END;
 
@@ -30,6 +32,8 @@ TYPE
     END;
 
     PredCodeMaker = RECORD (CodeMaker)
+        PROCEDURE PredCodeMaker(pred: CodePredicate);
+
         pred: CodePredicate
     END;
 
@@ -39,7 +43,6 @@ TYPE
 VAR
     openArrayChar: Types.PType;
     castOperations*: Cast.Operations;
-    castToUint8: POINTER TO CastToUint8;
 
 PROCEDURE binary(
     left, right: Code.PExpression; 
@@ -87,7 +90,7 @@ BEGIN
     ELSE
         resultPrecedence := precedence;
     END;
-    RETURN Code.makeExpressionWithPrecedence(resultCode, resultType, NIL, resultValue, resultPrecedence)
+    RETURN NEW Code.Expression(resultCode, resultType, NIL, resultValue, resultPrecedence)
 END binary;
 
 PROCEDURE SimpleCodeMaker.make(left, right: STRING; rtl: OberonRtl.PType): STRING;
@@ -104,32 +107,13 @@ BEGIN
     RETURN SELF.pred(left, right, rtl)
 END PredCodeMaker.make;
 
-PROCEDURE makeSimpleCodeMaker(code: STRING): PCodeMaker;
-VAR
-    result: POINTER TO SimpleCodeMaker;
-BEGIN
-    NEW(result);
-    result.code := code;
-    RETURN result
-END makeSimpleCodeMaker;
+PROCEDURE SimpleCodeMaker.SimpleCodeMaker(code: STRING)
+    | code(code);
+END;
 
-PROCEDURE makeIntCodeMaker(code: STRING): PCodeMaker;
-VAR
-    result: POINTER TO IntCodeMaker;
-BEGIN
-    NEW(result);
-    result.code := code;
-    RETURN result
-END makeIntCodeMaker;
-
-PROCEDURE makePredCodeMaker(pred: CodePredicate): PCodeMaker;
-VAR
-    result: POINTER TO PredCodeMaker;
-BEGIN
-    NEW(result);
-    result.pred := pred;
-    RETURN result
-END makePredCodeMaker;
+PROCEDURE PredCodeMaker.PredCodeMaker(pred: CodePredicate)
+    | pred(pred);
+END;
 
 PROCEDURE binaryWithCodeEx(
     left, right: Code.PExpression; 
@@ -145,7 +129,7 @@ PROCEDURE binaryWithCodeEx(
         right, 
         rtl, 
         op, 
-        makeSimpleCodeMaker(code), 
+        NEW SimpleCodeMaker(code), 
         precedence, 
         optResultType, 
         optResultPrecedence)
@@ -186,7 +170,7 @@ BEGIN
     IF e.type() # Types.basic.uint8 THEN
         result := e;
     ELSE
-        result := Code.makeExpressionWithPrecedence(
+        result := NEW Code.Expression(
                 e.code(),
                 Types.basic.integer,
                 e.designator(),
@@ -208,7 +192,7 @@ PROCEDURE binaryInt(
         right, 
         rtl, 
         op, 
-        makeIntCodeMaker(code), 
+        NEW IntCodeMaker(code), 
         precedence, 
         NIL, 
         Precedence.bitOr (* see IntCodeMaker.make *)
@@ -226,7 +210,7 @@ PROCEDURE binaryPred(
         right, 
         rtl, 
         op, 
-        makePredCodeMaker(pred), 
+        NEW PredCodeMaker(pred), 
         Precedence.none, 
         Types.basic.bool, 
         Precedence.none
@@ -592,7 +576,7 @@ PROCEDURE setSymmetricDiff*(left, right: Code.PExpression; rtl: OberonRtl.PType)
 END setSymmetricDiff;
 
 PROCEDURE setHasBit*(left, right: Code.PExpression; rtl: OberonRtl.PType): Code.PExpression;
-    RETURN Code.makeExpressionWithPrecedence(
+    RETURN NEW Code.Expression(
             "1 << " + Code.adjustPrecedence(Code.derefExpression(left), Precedence.shift) 
             + " & " + Code.adjustPrecedence(Code.derefExpression(right), Precedence.bitAnd),
             Types.basic.bool,
@@ -755,7 +739,7 @@ VAR
     derefExp: Code.PExpression;
 BEGIN
     derefExp := Code.derefExpression(e);
-    RETURN Code.makeExpressionWithPrecedence(
+    RETURN NEW Code.Expression(
             "(Math.log(" + derefExp.code() + ") / Math.LN2) | 0",
             Types.basic.integer,
             NIL,
@@ -782,8 +766,6 @@ PROCEDURE CastToUint8.make(rtl: OberonRtl.PType; e: Code.PExpression): Code.PExp
 END CastToUint8.make;
 
 BEGIN
-    openArrayChar := Types.makeOpenArray(Types.basic.ch);
-
-    NEW(castToUint8);
-    castOperations.castToUint8 := castToUint8;
+    openArrayChar := NEW Types.OpenArray(Types.basic.ch);
+    castOperations.castToUint8 := NEW CastToUint8();
 END Operator.

src/ob/Procedure.ob

@@ -51,6 +51,8 @@ TYPE
     PType = POINTER TO Type;
 
     Std* = RECORD(Types.Procedure)
+        PROCEDURE Std*(name: STRING; call: PCall);
+
         PROCEDURE callGenerator*(cx: LanguageContext.PType): PCallGenerator;
 
         call: PCall
@@ -159,20 +161,11 @@ BEGIN
     processArguments(actual, expected, NIL, types);
 END checkArguments;
 
-PROCEDURE initStd*(name: STRING; call: PCall; VAR result: Std);
-BEGIN
-    Types.initProcedure(result, name);
-    result.call := call;
-END initStd;
-
-PROCEDURE makeStd*(name: STRING; call: PCall): Types.PProcedure;
-VAR
-    result: POINTER TO Std;
+PROCEDURE Std.Std(name: STRING; call: PCall)
+    | SUPER(name);
 BEGIN
-    NEW(result);
-    initStd(name, call, result^);
-    RETURN result
-END makeStd;
+    SELF.call := call;
+END;
 
 PROCEDURE CallGeneratorImpl.handleArgument(e: Code.PExpression);
 BEGIN
@@ -184,11 +177,9 @@ PROCEDURE CallGeneratorImpl.end(): Code.PExpression;
 END;
 
 PROCEDURE makeCallGenerator*(call: PCall; cx: LanguageContext.PType): PCallGenerator;
-VAR
-    result: POINTER TO CallGeneratorImpl;
 BEGIN
     ASSERT(cx # NIL);
-    NEW(result);
+    result <- NEW CallGeneratorImpl();
     result.cx := cx;
     result.call := call;
     RETURN result
@@ -230,8 +221,6 @@ TYPE
         result: Types.PType;
         argumentsCode: PArgumentsCode
     END;
-VAR
-    call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     BEGIN
@@ -242,7 +231,7 @@ VAR
                 )
     END CallImpl.make;
 BEGIN
-    NEW(call);
+    call <- NEW CallImpl();
     call.args := type.args();
     call.result := type.result();
     call.argumentsCode := argumentsCode;
@@ -250,13 +239,11 @@ BEGIN
 END makeProcCallGeneratorWithCustomArgs;
 
 PROCEDURE makeArgumentsCode*(cx: Context.PType): PArgumentsCode;
-VAR
-    result: POINTER TO GenArgCode;
 BEGIN
-    NEW(result);
+    result <- NEW GenArgCode();
     result.cx := cx;
     RETURN result
-END makeArgumentsCode;
+END;
 
 PROCEDURE makeProcCallGenerator*(
     cx: LanguageContext.PType; 
@@ -278,47 +265,27 @@ PROCEDURE Std.designatorCode(id: STRING): STRING;
 END Std.designatorCode;
 
 PROCEDURE makeSymbol*(p: Types.PProcedure): Symbols.PSymbol;
-    RETURN Symbols.makeSymbol(p.name, Types.makeProcedure(p))
-END makeSymbol;
-
-PROCEDURE initStdCall*(call: PStdCall);
-BEGIN
-END initStdCall;
+    RETURN NEW Symbols.Symbol(p.name, NEW Types.ProcedureId(p))
+END;
 
 PROCEDURE hasArgument(call: PStdCall; type: Types.PType);
-VAR
-    a: Types.PProcedureArgument;
 BEGIN
-    NEW(a);
-    a.type := type;
-    call.args.add(a);
+    call.args.add(NEW Types.ProcedureArgument(type, FALSE));
 END hasArgument;
 
 PROCEDURE hasVarArgument(call: PStdCall; type: Types.PType);
-VAR
-    a: Types.PProcedureArgument;
 BEGIN
-    NEW(a);
-    a.isVar := TRUE;
-    a.type := type;
-    call.args.add(a);
+    call.args.add(NEW Types.ProcedureArgument(type, TRUE));
 END hasVarArgument;
 
 PROCEDURE hasArgumentWithCustomType*(call: PStdCall);
-VAR
-    a: Types.PProcedureArgument;
 BEGIN
-    NEW(a);
-    call.args.add(a);
+    call.args.add(NEW Types.ProcedureArgument(NIL, FALSE));
 END hasArgumentWithCustomType;
 
 PROCEDURE hasVarArgumnetWithCustomType(call: PStdCall);
-VAR
-    a: Types.PProcedureArgument;
 BEGIN
-    NEW(a);
-    a.isVar := TRUE;
-    call.args.add(a);
+    call.args.add(NEW Types.ProcedureArgument(NIL, TRUE));
 END hasVarArgumnetWithCustomType;
 
 PROCEDURE checkSingleArgument*(
@@ -338,8 +305,6 @@ PROCEDURE makeNew(): Symbols.PSymbol;
     TYPE
         CallImpl = RECORD(StdCall)
         END;
-    VAR
-        call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     VAR
@@ -362,10 +327,9 @@ PROCEDURE makeNew(): Symbols.PSymbol;
                 NIL)
     END CallImpl.make;
 BEGIN
-    NEW(call);
-    initStdCall(call);
+    call <- NEW CallImpl();
     hasVarArgumnetWithCustomType(call);
-    RETURN makeSymbol(makeStd("NEW", call))
+    RETURN makeSymbol(NEW Std("NEW", call))
 END makeNew;
 
 PROCEDURE lenArgumentCheck*(argType: Types.PType): BOOLEAN;
@@ -389,22 +353,17 @@ BEGIN
 END CallLen.make;
 
 PROCEDURE makeLen*(check: LenArgumentCheck): Symbols.PSymbol;
-VAR
-    call: POINTER TO CallLen;
 BEGIN
-    NEW(call);
-    initStdCall(call);
+    call <- NEW CallLen();
     call.check := check;
     hasArgumentWithCustomType(call);
-    RETURN makeSymbol(makeStd("LEN", call))
+    RETURN makeSymbol(NEW Std("LEN", call))
 END makeLen;
 
 PROCEDURE makeOdd(): Symbols.PSymbol;
     TYPE
         CallImpl = RECORD(StdCall)
         END;
-    VAR
-        call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     VAR
@@ -421,7 +380,7 @@ PROCEDURE makeOdd(): Symbols.PSymbol;
                 ORD(ODD(constValue^(Code.IntConst).value)));
         END;
 
-        RETURN Code.makeExpressionWithPrecedence(
+        RETURN NEW Code.Expression(
             code + " & 1",
             Types.basic.bool,
             NIL,
@@ -429,18 +388,15 @@ PROCEDURE makeOdd(): Symbols.PSymbol;
             Precedence.bitAnd)
     END CallImpl.make;
 BEGIN
-    NEW(call);
-    initStdCall(call);
+    call <- NEW CallImpl();
     hasArgument(call, Types.basic.integer);
-    RETURN makeSymbol(makeStd("ODD", call))
+    RETURN makeSymbol(NEW Std("ODD", call))
 END makeOdd;
 
 PROCEDURE makeAssert(): Symbols.PSymbol;
     TYPE
         CallImpl = RECORD(StdCall)
         END;
-    VAR
-        call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     VAR
@@ -452,10 +408,9 @@ PROCEDURE makeAssert(): Symbols.PSymbol;
                 NIL)
     END CallImpl.make;
 BEGIN
-    NEW(call);
-    initStdCall(call);
+    call <- NEW CallImpl();
     hasArgument(call, Types.basic.bool);
-    RETURN makeSymbol(makeStd("ASSERT", call))
+    RETURN makeSymbol(NEW Std("ASSERT", call))
 END makeAssert;
 
 PROCEDURE setBitImpl(name: STRING; bitOp: BinaryOpStr): Symbols.PSymbol;
@@ -464,8 +419,6 @@ PROCEDURE setBitImpl(name: STRING; bitOp: BinaryOpStr): Symbols.PSymbol;
             name: STRING;
             bitOp: BinaryOpStr
         END;
-    VAR
-        call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     VAR
@@ -512,13 +465,12 @@ PROCEDURE setBitImpl(name: STRING; bitOp: BinaryOpStr): Symbols.PSymbol;
             NIL)
     END CallImpl.make;
 BEGIN
-    NEW(call);
-    initStdCall(call);
+    call <- NEW CallImpl();
     call.name := name;
     call.bitOp := bitOp;
     hasVarArgument(call, Types.basic.set);
     hasArgument(call, Types.basic.integer);
-    RETURN makeSymbol(makeStd(call.name, call))
+    RETURN makeSymbol(NEW Std(call.name, call))
 END setBitImpl;
 
 PROCEDURE checkVariableArgumentsCount(min, max: INTEGER; actual: ARRAY OF Code.PExpression);
@@ -540,8 +492,6 @@ PROCEDURE incImpl(name: STRING; unary: STRING; incOp: BinaryOpStr): Symbols.PSym
             unary: STRING;
             incOp: BinaryOpStr
         END;
-    VAR
-        call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     VAR
@@ -571,14 +521,13 @@ PROCEDURE incImpl(name: STRING; unary: STRING; incOp: BinaryOpStr): Symbols.PSym
         RETURN Code.makeSimpleExpression(code, NIL)
     END CallImpl.make;
 BEGIN
-    NEW(call);
-    initStdCall(call);
+    call <- NEW CallImpl();
     call.name := name;
     call.unary := unary;
     call.incOp := incOp;
     hasVarArgument(call, Types.basic.integer);
     hasArgument(call, Types.basic.integer);
-    RETURN makeSymbol(makeStd(call.name, call))
+    RETURN makeSymbol(NEW Std(call.name, call))
 END incImpl;
 
 PROCEDURE inclOp(x, y: STRING): STRING;
@@ -601,8 +550,6 @@ PROCEDURE makeAbs(): Symbols.PSymbol;
     TYPE
         CallImpl = RECORD(StdCall)
         END;
-    VAR
-        call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     VAR
@@ -618,18 +565,15 @@ PROCEDURE makeAbs(): Symbols.PSymbol;
         RETURN Code.makeSimpleExpression("Math.abs(" + arg.code() + ")", argType)
     END CallImpl.make;
 BEGIN
-    NEW(call);
-    initStdCall(call);
+    call <- NEW CallImpl();
     hasArgumentWithCustomType(call);
-    RETURN makeSymbol(makeStd("ABS", call))
+    RETURN makeSymbol(NEW Std("ABS", call))
 END makeAbs;
 
 PROCEDURE makeFloor(): Symbols.PSymbol;
     TYPE
         CallImpl = RECORD(StdCall)
         END;
-    VAR
-        call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     VAR
@@ -641,18 +585,15 @@ PROCEDURE makeFloor(): Symbols.PSymbol;
             Types.basic.integer)
     END CallImpl.make;
 BEGIN
-    NEW(call);
-    initStdCall(call);
+    call <- NEW CallImpl();
     hasArgument(call, Types.basic.real);
-    RETURN makeSymbol(makeStd("FLOOR", call))
+    RETURN makeSymbol(NEW Std("FLOOR", call))
 END makeFloor;
 
 PROCEDURE makeFlt(): Symbols.PSymbol;
     TYPE
         CallImpl = RECORD(StdCall)
         END;
-    VAR
-        call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     VAR
@@ -664,7 +605,7 @@ PROCEDURE makeFlt(): Symbols.PSymbol;
         IF value # NIL THEN
             value := Code.makeRealConst(FLT(value^(Code.IntConst).value));
         END;
-        RETURN Code.makeExpressionWithPrecedence(
+        RETURN NEW Code.Expression(
                 arg.code(), 
                 Types.basic.real,
                 NIL,
@@ -672,10 +613,9 @@ PROCEDURE makeFlt(): Symbols.PSymbol;
                 arg.maxPrecedence())
     END CallImpl.make;
 BEGIN
-    NEW(call);
-    initStdCall(call);
+    call <- NEW CallImpl();
     hasArgument(call, Types.basic.integer);
-    RETURN makeSymbol(makeStd("FLT", call))
+    RETURN makeSymbol(NEW Std("FLT", call))
 END makeFlt;
 
 PROCEDURE bitShiftImpl(name: STRING; op: BinaryOp): Symbols.PSymbol;
@@ -684,8 +624,6 @@ PROCEDURE bitShiftImpl(name: STRING; op: BinaryOp): Symbols.PSymbol;
             name: STRING;
             op: BinaryOp
         END;
-    VAR
-        call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     BEGIN
@@ -694,21 +632,18 @@ PROCEDURE bitShiftImpl(name: STRING; op: BinaryOp): Symbols.PSymbol;
         RETURN SELF.op(args[0], args[1], cx.rtl)
     END CallImpl.make;
 BEGIN
-    NEW(call);
-    initStdCall(call);
+    call <- NEW CallImpl();
     call.name := name;
     call.op := op;
     hasArgument(call, Types.basic.integer);
     hasArgument(call, Types.basic.integer);
-    RETURN makeSymbol(makeStd(call.name, call))
+    RETURN makeSymbol(NEW Std(call.name, call))
 END bitShiftImpl;
 
 PROCEDURE makeOrd(): Symbols.PSymbol;
     TYPE
         CallImpl = RECORD(StdCall)
         END;
-    VAR
-        call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     VAR
@@ -730,7 +665,7 @@ PROCEDURE makeOrd(): Symbols.PSymbol;
         ELSIF argType = Types.basic.bool THEN
             code := Code.adjustPrecedence(arg, Precedence.conditional) 
                   + " ? 1 : 0";
-            result := Code.makeExpressionWithPrecedence(
+            result := NEW Code.Expression(
                 code, 
                 Types.basic.integer, 
                 NIL, 
@@ -751,18 +686,15 @@ PROCEDURE makeOrd(): Symbols.PSymbol;
         RETURN result
     END CallImpl.make;
 BEGIN
-    NEW(call);
-    initStdCall(call);
+    call <- NEW CallImpl();
     hasArgumentWithCustomType(call);
-    RETURN makeSymbol(makeStd("ORD", call))
+    RETURN makeSymbol(NEW Std("ORD", call))
 END makeOrd;
 
 PROCEDURE makeChr(): Symbols.PSymbol;
     TYPE
         CallImpl = RECORD(StdCall)
         END;
-    VAR
-        call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     VAR
@@ -772,18 +704,15 @@ PROCEDURE makeChr(): Symbols.PSymbol;
         RETURN Code.makeSimpleExpression(arg.code(), Types.basic.ch)
     END CallImpl.make;
 BEGIN
-    NEW(call);
-    initStdCall(call);
+    call <- NEW CallImpl();
     hasArgument(call, Types.basic.integer);
-    RETURN makeSymbol(makeStd("CHR", call))
+    RETURN makeSymbol(NEW Std("CHR", call))
 END makeChr;
 
 PROCEDURE makePack(): Symbols.PSymbol;
     TYPE
         CallImpl = RECORD(StdCall)
         END;
-    VAR
-        call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     VAR
@@ -797,19 +726,16 @@ PROCEDURE makePack(): Symbols.PSymbol;
             NIL)
     END CallImpl.make;
 BEGIN
-    NEW(call);
-    initStdCall(call);
+    call <- NEW CallImpl();
     hasVarArgument(call, Types.basic.real);
     hasArgument(call, Types.basic.integer);
-    RETURN makeSymbol(makeStd("PACK", call))
+    RETURN makeSymbol(NEW Std("PACK", call))
 END makePack;
 
 PROCEDURE makeUnpk(): Symbols.PSymbol;
     TYPE
         CallImpl = RECORD(StdCall)
         END;
-    VAR
-        call: POINTER TO CallImpl;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
     VAR
@@ -825,11 +751,10 @@ PROCEDURE makeUnpk(): Symbols.PSymbol;
             NIL)
     END CallImpl.make;
 BEGIN
-    NEW(call);
-    initStdCall(call);
+    call <- NEW CallImpl();
     hasVarArgument(call, Types.basic.real);
     hasVarArgument(call, Types.basic.integer);
-    RETURN makeSymbol(makeStd("UNPK", call))
+    RETURN makeSymbol(NEW Std("UNPK", call))
 END makeUnpk;
 
 PROCEDURE dumpProcArgs(proc: Type): STRING;
@@ -894,15 +819,6 @@ PROCEDURE Type.result(): Types.PType;
     RETURN SELF.mResult
 END Type.result;
 
-PROCEDURE make*(name: STRING): PType;
-VAR
-    result: PType;
-BEGIN
-    NEW(result);
-    result.name := name;
-    RETURN result
-END make;
-
 BEGIN
     predefined.add(makeNew());
     predefined.add(makeOdd());

src/ob/Scope.ob

@@ -10,12 +10,16 @@ IMPORT
 TYPE
     Unresolved = ARRAY * OF STRING;
 
-    Finalizer = POINTER TO RECORD
+    Finalizer = RECORD
+        PROCEDURE Finalizer(proc: ScopeBase.FinalizerProc; closure: Object.PType);
+
         proc: ScopeBase.FinalizerProc;
         closure: Object.PType
     END;
 
     Type* = RECORD(ScopeBase.Type)
+        PROCEDURE Type*(stdSymbols: JsMap.Type);
+
         PROCEDURE addSymbol*(s: Symbols.PSymbol; exported: BOOLEAN);
         PROCEDURE findSymbol*(id: STRING): Symbols.PFoundSymbol;
         PROCEDURE close();
@@ -23,7 +27,7 @@ TYPE
         stdSymbols: JsMap.Type;
         symbols: JsMap.Type;
         unresolved: Unresolved;
-        finalizers: ARRAY * OF Finalizer
+        finalizers: ARRAY * OF POINTER TO Finalizer
     END;
     PType* = POINTER TO Type;
 
@@ -31,13 +35,16 @@ TYPE
     END;
 
     CompiledModule = RECORD(Types.Module)
+        PROCEDURE CompiledModule(name: STRING);
+
         PROCEDURE findSymbol(id: STRING): Symbols.PFoundSymbol;
 
         exports: JsMap.Type
     END;
-    PCompiledModule = POINTER TO CompiledModule;
 
     Module* = RECORD(Type)
+        PROCEDURE Module*(name: STRING; stdSymbols: JsMap.Type);
+
         symbol: Symbols.PSymbol;
         exports: JsMap.Type
     END;
@@ -48,7 +55,7 @@ VAR
     name: STRING;
 BEGIN
     name := Types.typeName(t^);
-    JsMap.put(result, name, Symbols.makeSymbol(name, Types.makeTypeId(t)));
+    JsMap.put(result, name, NEW Symbols.Symbol(name, NEW Types.TypeId(t)));
 END addSymbolForType;
 
 PROCEDURE makeStdSymbols*(): JsMap.Type;
@@ -75,33 +82,23 @@ BEGIN
     RETURN result
 END makeStdSymbols;
 
-PROCEDURE init*(VAR scope: Type; stdSymbols: JsMap.Type);
-BEGIN
-    scope.stdSymbols := stdSymbols;
-    scope.symbols := JsMap.make();
-END init;
+PROCEDURE Type.Type(stdSymbols: JsMap.Type)
+    | stdSymbols(stdSymbols),
+      symbols(JsMap.make());
+END;
 
-PROCEDURE makeCompiledModule(name: STRING): PCompiledModule;
-VAR
-    result: PCompiledModule;
-BEGIN
-    NEW(result);
-    Types.initModule(result^, name);
-    result.exports := JsMap.make();
-    RETURN result
-END makeCompiledModule;
+PROCEDURE CompiledModule.CompiledModule(name: STRING)
+    | SUPER(name),
+      exports(JsMap.make());
+END;
 
-PROCEDURE makeModule*(name: STRING; stdSymbols: JsMap.Type): PModule;
-VAR
-    result: PModule;
+PROCEDURE Module.Module(name: STRING; stdSymbols: JsMap.Type)
+    | SUPER(stdSymbols),
+      symbol(NEW Symbols.Symbol(name, NEW CompiledModule(name))),
+      exports(JsMap.make());
 BEGIN
-    NEW(result);
-    init(result^, stdSymbols);
-    result.exports := JsMap.make();
-    result.symbol := Symbols.makeSymbol(name, makeCompiledModule(name));
-    result.addSymbol(result.symbol, FALSE);
-    RETURN result
-END makeModule;
+    SELF.addSymbol(SELF.symbol, FALSE);
+END;
 
 PROCEDURE addUnresolved*(s: Type; id: STRING);
 BEGIN
@@ -147,15 +144,15 @@ BEGIN
     SELF.finalizers.clear(); 
 END Type.close;
 
+PROCEDURE Finalizer.Finalizer(proc: ScopeBase.FinalizerProc; closure: Object.PType)
+    | proc(proc),
+      closure(closure);
+END;
+
 PROCEDURE Type.addFinalizer(proc: ScopeBase.FinalizerProc; closure: Object.PType);
-VAR
-    f: Finalizer;
 BEGIN
-    NEW(f);
-    f.proc := proc;
-    f.closure := closure;
-    SELF.finalizers.add(f);
-END Type.addFinalizer;
+    SELF.finalizers.add(NEW Finalizer(proc, closure));
+END;
 
 PROCEDURE close*(s: Type): Unresolved;
     RETURN s.unresolved
@@ -181,7 +178,7 @@ BEGIN
         void <- JsMap.find(SELF.stdSymbols, id, result);
     END;
     IF result # NIL THEN
-        found := Symbols.makeFound(result(Symbols.PSymbol), SELF(POINTER))
+        found := NEW Symbols.FoundSymbol(result(Symbols.PSymbol), SELF(POINTER))
     END;
     RETURN found
 END Type.findSymbol;
@@ -203,13 +200,8 @@ BEGIN
 END Procedure.addSymbol;
 
 PROCEDURE makeProcedure*(stdSymbols: JsMap.Type): PType;
-VAR
-    result: POINTER TO Procedure;
-BEGIN
-    NEW(result);
-    init(result^, stdSymbols);
-    RETURN result
-END makeProcedure;
+    RETURN NEW Procedure(stdSymbols);
+END;
 
 PROCEDURE addExport(id: STRING; value: Object.PType; VAR closure: Object.Type);
 VAR
@@ -219,7 +211,7 @@ BEGIN
     symbol := value(Symbols.PSymbol);
     info := symbol.info();
     IF info IS Types.PVariable THEN
-        symbol := Symbols.makeSymbol(id, Types.makeExportedVariable(info(Types.PVariable)^));
+        symbol := NEW Symbols.Symbol(id, Types.makeExportedVariable(info(Types.PVariable)^));
     END;
     JsMap.put(closure(CompiledModule).exports, id, symbol);
 END addExport;
@@ -235,7 +227,7 @@ VAR
     result: Symbols.PFoundSymbol;
 BEGIN
     IF JsMap.find(SELF.exports, id, s) THEN
-        result := Symbols.makeFound(s(Symbols.PSymbol), NIL);
+        result := NEW Symbols.FoundSymbol(s(Symbols.PSymbol), NIL);
     END;
     RETURN result
 END CompiledModule.findSymbol;

src/ob/Stream.ob

@@ -5,20 +5,18 @@ CONST
     kCR* = 0AX;
 
 TYPE
-    Type* = POINTER TO RECORD
+    Type* = RECORD
+        PROCEDURE Type*(text: STRING);
+
         s: STRING;
         pos: INTEGER
     END;
 
     ReaderProc = PROCEDURE(c: CHAR): BOOLEAN;
 
-PROCEDURE make*(text: STRING): Type;
-VAR result: Type;
-BEGIN
-    NEW(result);
-    result.s := text;
-    RETURN result
-END make;
+PROCEDURE Type.Type(text: STRING)
+    | s(text);
+END;
 
 PROCEDURE eof*(self: Type): BOOLEAN;
     RETURN self.pos = LEN(self.s)
@@ -28,13 +26,13 @@ PROCEDURE pos*(self: Type): INTEGER;
     RETURN self.pos
 END pos;
 
-PROCEDURE setPos*(self: Type; pos: INTEGER);
+PROCEDURE setPos*(VAR self: Type; pos: INTEGER);
 BEGIN
     ASSERT(pos <= LEN(self.s));
     self.pos := pos
 END setPos;
 
-PROCEDURE next*(self: Type; n: INTEGER);
+PROCEDURE next*(VAR self: Type; n: INTEGER);
 BEGIN
     ASSERT(self.pos + n <= LEN(self.s));
     self.pos := self.pos + n;
@@ -46,7 +44,7 @@ BEGIN
     RETURN self.s[self.pos]
 END peekChar;
 
-PROCEDURE getChar*(self: Type): CHAR;
+PROCEDURE getChar*(VAR self: Type): CHAR;
 VAR result: CHAR;
 BEGIN
     ASSERT(~eof(self));
@@ -69,7 +67,7 @@ BEGIN
     RETURN result
 END peekStr;
 
-PROCEDURE read*(self: Type; f: ReaderProc): BOOLEAN;
+PROCEDURE read*(VAR self: Type; f: ReaderProc): BOOLEAN;
 BEGIN
     WHILE ~eof(self) & f(peekChar(self)) DO
         next(self, 1);

src/ob/Symbols.ob

@@ -2,6 +2,8 @@ MODULE Symbols;
 IMPORT Object, ScopeBase, Types;
 TYPE
     Symbol* = RECORD(Object.Type)
+        PROCEDURE Symbol*(id: STRING; info: Types.PId);
+
         PROCEDURE id*(): STRING;
         PROCEDURE info*(): Types.PId;
         PROCEDURE isModule*(): BOOLEAN;
@@ -17,6 +19,8 @@ TYPE
     PSymbol* = POINTER TO Symbol;
 
     FoundSymbol* = RECORD
+        PROCEDURE FoundSymbol*(s: PSymbol; scope: ScopeBase.PType);
+
         PROCEDURE symbol(): PSymbol;
         PROCEDURE scope*(): ScopeBase.PType;
 
@@ -62,24 +66,14 @@ PROCEDURE FoundSymbol.symbol(): PSymbol;
     RETURN SELF.mSymbol
 END FoundSymbol.symbol;
 
-PROCEDURE makeSymbol*(id: STRING; info: Types.PId): PSymbol;
-VAR
-    result: PSymbol;
-BEGIN
-    NEW(result);
-    result.mId := id;
-    result.mInfo := info;
-    RETURN result
-END makeSymbol;
-
-PROCEDURE makeFound*(s: PSymbol; scope: ScopeBase.PType): PFoundSymbol;
-VAR
-    result: PFoundSymbol;
-BEGIN
-    NEW(result);
-    result.mSymbol := s;
-    result.mScope := scope;
-    RETURN result
-END makeFound;
+PROCEDURE Symbol.Symbol(id: STRING; info: Types.PId)
+    | mId(id),
+      mInfo(info);
+END;
+
+PROCEDURE FoundSymbol.FoundSymbol(s: PSymbol; scope: ScopeBase.PType)
+    | mSymbol(s),
+      mScope(scope);
+END;
 
 END Symbols.

src/ob/Types.ob

@@ -20,6 +20,8 @@ TYPE
     PStorageType* = POINTER TO StorageType;
 
     TypeId* = RECORD(Id)
+        PROCEDURE TypeId*(type: PType);
+
         PROCEDURE type*(): PType;
         PROCEDURE description(): STRING;
         PROCEDURE strip();
@@ -31,17 +33,22 @@ TYPE
     ResolveTypeCallback = PROCEDURE(): PType;
 
     ForwardTypeId* = RECORD(TypeId)
+        PROCEDURE ForwardTypeId(resolve: ResolveTypeCallback);
+
         resolve: ResolveTypeCallback
     END;
 
     PForwardTypeId = POINTER TO ForwardTypeId;
 
-    LazyTypeId = RECORD(TypeId)
+    LazyTypeId* = RECORD(TypeId)
+        PROCEDURE LazyTypeId*();
     END;
 
     PLazyTypeId = POINTER TO LazyTypeId;
 
     Const* = RECORD(Id)
+        PROCEDURE Const*(type: PType; value: JS.var);
+
         type: PType;
         value: JS.var
     END;
@@ -57,12 +64,15 @@ TYPE
     PVariable* = POINTER TO Variable;
 
     VariableImpl = RECORD(Variable)
+        PROCEDURE VariableImpl(type: PType; ref: BOOLEAN);
+
         mType: PType;
         mRef: BOOLEAN
     END;
     PVariableImpl = POINTER TO VariableImpl;
 
     ReadOnlyVariable = RECORD(VariableImpl)
+        PROCEDURE ReadOnlyVariable(type: PType);
     END;
 
     ExportedVariable = RECORD(ReadOnlyVariable)
@@ -71,12 +81,16 @@ TYPE
     PExportedVariable = POINTER TO ExportedVariable;
 
     ProcedureId* = RECORD(Id)
+        PROCEDURE ProcedureId*(type: PType);
+
         type*: PType
     END;
 
     PProcedureId* = POINTER TO ProcedureId;
 
     String* = RECORD(Type)
+        PROCEDURE String*(s: STRING);
+
         s-: STRING
     END;
 
@@ -91,6 +105,8 @@ TYPE
     PField* = POINTER TO Field;
 
     RecordField* = RECORD(Field)
+        PROCEDURE RecordField*(identdef: Context.PIdentdefInfo; type: PType);
+
         PROCEDURE identdef*(): Context.PIdentdefInfo;
 
         mIdentdef: Context.PIdentdefInfo;
@@ -99,12 +115,16 @@ TYPE
     PRecordField* = POINTER TO RecordField;
 
     NamedType* = RECORD(StorageType)
+        PROCEDURE NamedType(name: STRING);
+
         PROCEDURE denote*(id: STRING): PField;
 
         name*: STRING
     END;
 
     Array* = RECORD(NamedType)
+        PROCEDURE Array*(elementsType: PType);
+
         elementsType-: PType
     END;
     PArray* = POINTER TO Array;
@@ -114,6 +134,8 @@ TYPE
     POpenArray* = POINTER TO OpenArray;
 
     StaticArray* = RECORD(Array)
+        PROCEDURE StaticArray*(initializer: STRING; elementsType: PType; len: INTEGER); 
+
         PROCEDURE length*(): INTEGER;
 
         mInitializer: STRING;
@@ -124,6 +146,8 @@ TYPE
     PRecord* = POINTER TO Record;
 
     Pointer* = RECORD(NamedType)
+        PROCEDURE Pointer*(name: STRING; base: PTypeId);
+
         base: PTypeId
     END;
 
@@ -135,6 +159,8 @@ TYPE
     PProcedure* = POINTER TO Procedure;
 
     ProcedureArgument* = RECORD (Object.Type)
+        PROCEDURE ProcedureArgument*(type: PType; isVar: BOOLEAN);
+
         PROCEDURE description(): STRING;
 
         type*: PType;
@@ -151,12 +177,16 @@ TYPE
     PDefinedProcedure* = POINTER TO DefinedProcedure;
 
     BasicType* = RECORD(NamedType)
+        PROCEDURE BasicType*(name: STRING; initializer: STRING);
+
         mInitializer: STRING
     END;
 
     PBasicType* = POINTER TO BasicType;
 
     Record* = RECORD(NamedType)
+        PROCEDURE Record*(name: STRING; cons: STRING; scope: ScopeBase.PType);
+
         PROCEDURE setBase*(type: PRecord);
         PROCEDURE addField*(f: PField);
         PROCEDURE findSymbol*(id: STRING): PField;
@@ -171,6 +201,7 @@ TYPE
     END;
     
     NonExportedRecord* = RECORD(Record)
+        PROCEDURE NonExportedRecord(cons: STRING; scope: ScopeBase.PType; base: PRecord);
     END;
     PNonExportedRecord* = POINTER TO NonExportedRecord;
 
@@ -178,6 +209,8 @@ TYPE
     END;
 
     Module* = RECORD(Id)
+        PROCEDURE Module*(name: STRING);
+
         name: STRING
     END;
 
@@ -222,24 +255,20 @@ BEGIN
     SELF.notExported.clear();
 END Record.finalize;
 
-PROCEDURE initRecord*(r: PRecord; name: STRING; cons: STRING; scope: ScopeBase.PType);
+PROCEDURE Record.Record(name: STRING; cons: STRING; scope: ScopeBase.PType)
+    | SUPER(name),
+      fields(JsMap.make()),
+      cons(cons),
+      scope(scope);
 BEGIN
-    r.name := name;
-    r.cons := cons;
-    r.scope := scope;
-    r.fields := JsMap.make();
-    scope.addFinalizer(finalizeRecord, r);
-END initRecord;
-
-PROCEDURE makeNonExportedRecord(cons: STRING; scope: ScopeBase.PType; base: PRecord): PNonExportedRecord;
-VAR
-    result: PNonExportedRecord;
+    scope.addFinalizer(finalizeRecord, SELF(POINTER));
+END;
+
+PROCEDURE NonExportedRecord.NonExportedRecord(cons: STRING; scope: ScopeBase.PType; base: PRecord)
+    | SUPER("", cons, scope);
 BEGIN
-    NEW(result);
-    initRecord(result, "", cons, scope);
-    result.base := base;
-    RETURN result
-END makeNonExportedRecord;    
+    SELF.base := base;
+END;    
 
 PROCEDURE TypeId.strip();
 VAR
@@ -247,20 +276,16 @@ VAR
 BEGIN
     IF SELF.mType IS PRecord THEN
         r := SELF.mType(PRecord);
-        SELF.mType := makeNonExportedRecord(r.cons, r.scope, r.base);
+        SELF.mType := NEW NonExportedRecord(r.cons, r.scope, r.base);
     ELSE
         SELF.mType := NIL;
     END;
 END TypeId.strip;
 
-PROCEDURE makeForwardTypeId*(resolve: ResolveTypeCallback): PForwardTypeId;
-VAR
-    result: PForwardTypeId;
-BEGIN
-    NEW(result);
-    result.resolve := resolve;
-    RETURN result
-END makeForwardTypeId;
+PROCEDURE ForwardTypeId.ForwardTypeId(resolve: ResolveTypeCallback)
+    | SUPER(NIL),
+      resolve(resolve);
+END;
 
 PROCEDURE ForwardTypeId.type(): PType;
 BEGIN
@@ -330,6 +355,10 @@ PROCEDURE Variable.idType(): STRING;
     RETURN "variable"
 END Variable.idType;
 
+PROCEDURE ReadOnlyVariable.ReadOnlyVariable(type: PType)
+    | SUPER(type, FALSE);
+END;
+
 PROCEDURE ReadOnlyVariable.idType(): STRING;
     RETURN "read-only variable"
 END ReadOnlyVariable.idType;
@@ -391,15 +420,10 @@ PROCEDURE moduleName*(m: Module): STRING;
     RETURN m.name
 END moduleName;
 
-PROCEDURE makeBasic*(name: STRING; initializer: STRING): PBasicType;
-VAR
-    result: PBasicType;
-BEGIN
-    NEW(result);
-    result.name := name;
-    result.mInitializer := initializer;
-    RETURN result
-END makeBasic;
+PROCEDURE BasicType.BasicType(name: STRING; initializer: STRING)
+    | SUPER(name),
+      mInitializer(initializer);
+END;
 
 PROCEDURE Record.description(): STRING;
 VAR
@@ -622,180 +646,88 @@ BEGIN
     RETURN result + SELF.type.description()
 END ProcedureArgument.description;
 
-PROCEDURE makeProcedureArgument*(type: PType; isVar: BOOLEAN): PProcedureArgument;
-VAR
-    result: PProcedureArgument;
-BEGIN
-    NEW(result);
-    result.type := type;
-    result.isVar := isVar;
-    RETURN result
-END makeProcedureArgument;
+PROCEDURE ProcedureArgument.ProcedureArgument(type: PType; isVar: BOOLEAN)
+    | type(type),
+      isVar(isVar);
+END;
 
 PROCEDURE Module.idType(): STRING;
     RETURN "MODULE"
 END Module.idType;
 
-PROCEDURE makeTypeId*(type: PType): PTypeId;
-VAR
-    result: PTypeId;
-BEGIN
-    NEW(result);
-    result.mType := type;
-    RETURN result
-END makeTypeId;
-
-PROCEDURE makeLazyTypeId*(): PLazyTypeId;
-VAR
-    result: PLazyTypeId;
-BEGIN
-    NEW(result);
-    RETURN result
-END makeLazyTypeId;
+PROCEDURE TypeId.TypeId(type: PType)
+    | mType(type);
+END;
 
-PROCEDURE makeString*(s: STRING): PString;
-VAR
-    result: PString;
-BEGIN
-    NEW(result);
-    result.s := s;
-    RETURN result
-END makeString;
+PROCEDURE LazyTypeId.LazyTypeId()
+    | SUPER(NIL);
+END;
 
-PROCEDURE initArray*(elementsType: PType; VAR result: Array);
-BEGIN
-    result.elementsType := elementsType;
-END initArray;
+PROCEDURE String.String(s: STRING)
+    | s(s);
+END;
 
-PROCEDURE makeOpenArray*(elementsType: PType): PArray;
-VAR
-    result: POpenArray;
-BEGIN
-    NEW(result);
-    initArray(elementsType, result^);
-    RETURN result
-END makeOpenArray;
+PROCEDURE NamedType.NamedType(name: STRING)
+    | name(name);
+END;
 
-PROCEDURE initStaticArray*(
-    initializer: STRING;
-    elementsType: PType;
-    len: INTEGER;
-    VAR result: StaticArray
-    );
+PROCEDURE Array.Array(elementsType: PType)
+    | SUPER(""),
+      elementsType(elementsType);
 BEGIN
-    initArray(elementsType, result);
-    result.mInitializer := initializer;
-    result.len := len;
-END initStaticArray;
+END;
 
-PROCEDURE makeStaticArray*(
+PROCEDURE StaticArray.StaticArray(
     initializer: STRING;
     elementsType: PType;
-    len: INTEGER
-    ): PArray;
-VAR
-    result: PStaticArray;
-BEGIN
-    NEW(result);
-    initStaticArray(initializer, elementsType, len, result^);
-    RETURN result
-END makeStaticArray;
+    len: INTEGER ) | 
+    SUPER(elementsType),
+    mInitializer(initializer),
+    len(len);
+END;
 
-PROCEDURE makePointer*(name: STRING; base: PTypeId): PPointer;
-VAR
-    result: PPointer;
-BEGIN
-    NEW(result);
-    result.name := name;
-    result.base := base;
-    RETURN result
-END makePointer;
+PROCEDURE Pointer.Pointer(name: STRING; base: PTypeId)
+    | SUPER(name),
+      base(base);
+END;
 
-PROCEDURE makeRecord*(name: STRING; cons: STRING; scope: ScopeBase.PType): PRecord;
-VAR
-    result: PRecord;
-BEGIN
-    NEW(result);
-    initRecord(result, name, cons, scope);
-    RETURN result
-END makeRecord;
+PROCEDURE Const.Const(type: PType; value: JS.var)
+    | type(type),
+      value(value);
+END;
 
-PROCEDURE makeConst*(type: PType; value: JS.var): PConst;
-VAR
-    result: PConst;
-BEGIN
-    NEW(result);
-    result.type := type;
-    result.value := value;
-    RETURN result
-END makeConst;
+PROCEDURE VariableImpl.VariableImpl(type: PType; ref: BOOLEAN)
+    | mType(type),
+      mRef(ref);
+END;
 
 PROCEDURE makeVariable*(type: PType; readOnly: BOOLEAN): PVariable;
 VAR
     result: PVariableImpl;
-
-    PROCEDURE make(): PVariableImpl;
-    VAR
-        result: PVariableImpl;
-    BEGIN
-        NEW(result);
-        RETURN result
-    END make;
-
-    PROCEDURE makeRO(): PVariableImpl;
-    VAR
-        result: POINTER TO ReadOnlyVariable;
-    BEGIN
-        NEW(result);
-        RETURN result
-    END makeRO;
 BEGIN
     IF readOnly THEN
-        result := makeRO();
+        result := NEW ReadOnlyVariable(type);
     ELSE
-        result := make();
+        result := NEW VariableImpl(type, FALSE);
     END;
-    result.mType := type;
     RETURN result
 END makeVariable;
 
 PROCEDURE makeVariableRef*(type: PType): PVariable;
-VAR
-    result: PVariableImpl;
-BEGIN
-    NEW(result);
-    result.mType := type;
-    result.mRef := TRUE;
-    RETURN result
-END makeVariableRef;
-
-PROCEDURE makeExportedVariable*(v: Variable): PExportedVariable;
-VAR
-    result: PExportedVariable;
-BEGIN
-    NEW(result);
-    result.mType := v.type();
-    RETURN result
-END makeExportedVariable;
+    RETURN NEW VariableImpl(type, TRUE);
+END;
 
-PROCEDURE makeProcedure*(type: PType): PProcedureId;
-VAR
-    result: PProcedureId;
-BEGIN
-    NEW(result);
-    result.type := type;
-    RETURN result
-END makeProcedure;
+PROCEDURE makeExportedVariable*(v: Variable): PVariable;
+    RETURN NEW ExportedVariable(v.type());
+END;
 
-PROCEDURE initProcedure*(VAR p: Procedure; name: STRING);
-BEGIN
-    p.name := name;
-END initProcedure;
+PROCEDURE ProcedureId.ProcedureId(type: PType)
+    | type(type);
+END;
 
-PROCEDURE initModule*(VAR m: Module; name: STRING);
-BEGIN
-    m.name := name;
-END initModule;
+PROCEDURE Module.Module(name: STRING)
+    | name(name);
+END;
 
 PROCEDURE RecordField.id(): STRING;
     RETURN SELF.mIdentdef.id();
@@ -817,19 +749,9 @@ PROCEDURE RecordField.asVar(isReadOnly: BOOLEAN; cx: Context.Type): PId;
     RETURN makeVariable(SELF.mType, isReadOnly);
 END;
 
-PROCEDURE initRecordField*(identdef: Context.PIdentdefInfo; type: PType; VAR result: RecordField);
-BEGIN
-    result.mIdentdef := identdef;
-    result.mType := type;
-END;
-
-PROCEDURE makeRecordField*(identdef: Context.PIdentdefInfo; type: PType): PRecordField;
-VAR
-    result: PRecordField;
-BEGIN
-    NEW(result);
-    initRecordField(identdef, type, result^);
-    RETURN result;
+PROCEDURE RecordField.RecordField(identdef: Context.PIdentdefInfo; type: PType)
+    | mIdentdef(identdef),
+      mType(type);
 END;
 
 PROCEDURE mangleJSProperty*(id: STRING): STRING;
@@ -855,12 +777,12 @@ BEGIN
 END;
 
 BEGIN
-    basic.bool := makeBasic("BOOLEAN", "false");
-    basic.ch := makeBasic("CHAR", "0");
-    basic.integer := makeBasic("INTEGER", "0");
-    basic.uint8 := makeBasic("BYTE", "0");
-    basic.real := makeBasic("REAL", "0");
-    basic.set := makeBasic("SET", "0");
+    basic.bool := NEW BasicType("BOOLEAN", "false");
+    basic.ch := NEW BasicType("CHAR", "0");
+    basic.integer := NEW BasicType("INTEGER", "0");
+    basic.uint8 := NEW BasicType("BYTE", "0");
+    basic.real := NEW BasicType("REAL", "0");
+    basic.set := NEW BasicType("SET", "0");
 
     numeric.add(basic.integer);
     numeric.add(basic.uint8);

src/oberon/oberon_context.js

@@ -9,7 +9,7 @@ var Type = require("js/Types.js");
 
 var RecordDecl = Context.RecordDecl.extend({
     init: function OberonContext$RecordDecl(context){
-        Context.RecordDecl.prototype.init.call(this, context, Type.makeRecord);
+        Context.RecordDecl.prototype.init.call(this, context, Type.Record);
     }
 });
 
@@ -49,7 +49,7 @@ var ProcedureCall = Context.Chained.extend({
     callExpression: function(){return this.__callExpression;},
     endParse: function(){
         var e = this.__procCall.end();
-        this.__callExpression = Code.makeExpressionWithPrecedence(this.__id + e.code(), e.type(), undefined, e.constValue(), e.maxPrecedence());
+        this.__callExpression = new Code.Expression(this.__id + e.code(), e.type(), undefined, e.constValue(), e.maxPrecedence());
     }
 });
 

src/oberon/oberon_grammar.js

@@ -117,8 +117,8 @@ exports.language = {
     stdSymbols: Symbols.makeStd(),
     types: {
         implicitCast: Cast.implicit,
-        makeStaticArray: Types.makeStaticArray,
-        makeOpenArray: Types.makeOpenArray
+        StaticArray: Types.StaticArray,
+        OpenArray: Types.OpenArray
     },
     codeGenerator: {
         make: CodeGenerator.makeGenerator,

src/oc.js

@@ -50,7 +50,7 @@ function compileModulesFromText(
         resolveModule,
         handleCompiledModule,
         handleErrors){
-    var stream = Stream.make(text);
+    var stream = new Stream.Type(text);
     do {
         var context = contextFactory(resolveModule);
         var module = compileModule(grammar, stream, context, handleErrors);
@@ -123,7 +123,7 @@ function compileModules(names, moduleReader, grammar, contextFactory, handleErro
 function compile(text, language, handleErrors){
     var result = "";
     var rtl = new RTL();
-    var moduleCode = function(name, imports){return Code.makeModuleGenerator(name, imports);};
+    var moduleCode = function(name, imports){return new Code.ModuleGenerator(name, imports);};
     var resolver = makeResolver(
             language.grammar,
             function(moduleResolver){

src/parser.js

@@ -6,7 +6,7 @@ var Lexer = require("js/Lexer.js");
 var Stream = require("js/Stream.js");
 
 function literal(s){
-	var l = Lexer.makeLiteral(s);
+	var l = new Lexer.Literal(s);
 	return function(stream, context){
 		return Lexer.literal(l, stream, context);
 	};

test/test_unit_common.js

@@ -36,7 +36,7 @@ var TestContext = Context.Context.extend({
                   types: language.types,
                   stdSymbols: language.stdSymbols
                 });
-        this.pushScope(Scope.makeModule("test", language.stdSymbols));
+        this.pushScope(new Scope.Module("test", language.stdSymbols));
     },
     qualifyScope: function(){return "";},
     handleMessage: function(){}
@@ -60,7 +60,7 @@ function testWithSetup(setup, pass, fail){
 }
 
 function parseInContext(grammar, s, context){
-    var stream = Stream.make(s);
+    var stream = new Stream.Type(s);
     if (!grammar(stream, context) || !Stream.eof(stream))
         throw new Errors.Error("not parsed");
 }
@@ -162,11 +162,11 @@ function testWithModule(src, language, pass, fail){
     var grammar = language.grammar;
     return testWithSetup(
         function(){
-            var imported = oc.compileModule(grammar, Stream.make(src), makeContext(language));
+            var imported = oc.compileModule(grammar, new Stream.Type(src), makeContext(language));
             var module = imported.symbol().info();
             return setup(function(s){
                 oc.compileModule(grammar,
-                                 Stream.make(s),
+                                 new Stream.Type(s),
                                  new TestContextWithModule(module, language));
             });},
         pass,