expression parsing refactoring

src/eberon/EberonContextDesignator.ob

@@ -56,13 +56,6 @@ TYPE
         expression: Expression.PType;
     END;
 
-    PromoteTypeMsg* = RECORD(ContextHierarchy.Message)
-        PROCEDURE PromoteTypeMsg*(info: EberonTypePromotion.PVariable; type: Types.PStorageType);
-
-        info-: EberonTypePromotion.PVariable;
-        type-: Types.PStorageType;
-    END;
-
     TransferPromotedTypesMsg* = RECORD(ContextHierarchy.Message)
         PROCEDURE TransferPromotedTypesMsg*(p: EberonTypePromotion.PCombined); 
 
@@ -171,8 +164,6 @@ BEGIN
     IF msg IS TransferPromotedTypesMsg THEN
         msg.promotion.clear();
         result := TRUE;
-    ELSIF msg IS PromoteTypeMsg THEN
-        result := TRUE;
     END;
     RETURN result;
 END;
@@ -427,11 +418,6 @@ PROCEDURE OperatorNewMsg.OperatorNewMsg(e: Expression.PType)
     | expression(e);
 END;
 
-PROCEDURE PromoteTypeMsg.PromoteTypeMsg(info: EberonTypePromotion.PVariable; type: Types.PStorageType)
-    | info(info),
-      type(type);
-END;
-
 PROCEDURE TransferPromotedTypesMsg.TransferPromotedTypesMsg(p: EberonTypePromotion.PCombined)
     | promotion(p); 
 END;

src/eberon/EberonContextExpression.ob

@@ -56,7 +56,8 @@ TYPE
         PROCEDURE Node(parentTerm: PTermList);
 
         parentTerm: PTermList;
-        currentTypePromotion: EberonTypePromotion.PCombined;
+        combinedTypePromotion: EberonTypePromotion.PCombined;
+        varTypePromotion: EberonTypePromotion.PType;
     END;
     PNode = POINTER TO Node;
 
@@ -207,9 +208,13 @@ END;
 PROCEDURE RelationExpression.endParse(): BOOLEAN;
 BEGIN
     node <- SELF.node(PNode); 
-    IF node.currentTypePromotion # NIL THEN
-        void <- SELF.parent().handleMessage(
-            NEW EberonContextDesignator.TransferPromotedTypesMsg(node.currentTypePromotion)^);
+    IF node.combinedTypePromotion # NIL THEN
+        msg <- EberonContextDesignator.TransferPromotedTypesMsg(node.combinedTypePromotion);
+        void <- SELF.parent().handleMessage(msg);
+    END;
+    IF node.varTypePromotion # NIL THEN
+        msg <- ExpressionTypePromotion(node.varTypePromotion);
+        void <- SELF.parent().handleMessage(msg);
     END;
     RETURN SUPER();
 END;
@@ -264,22 +269,6 @@ BEGIN
     RETURN term.currentPromotion;
 END;
 
-PROCEDURE Term.handleMessage(VAR msg: ContextHierarchy.Message): Object.PType;
-VAR
-    result: Object.PType;
-BEGIN
-    IF msg IS EberonContextDesignator.PromoteTypeMsg THEN
-        promoted <- msg.info;
-        p <- setTermTypePromotion(SELF.list^(TermList));
-        IF p # NIL THEN
-            p.promote(promoted, msg.type);
-        END;
-    ELSE
-        result := SUPER(msg);
-    END;
-    RETURN result;
-END;
-
 PROCEDURE TermList.addOp(op: STRING);
 BEGIN
     SUPER(op);
@@ -379,31 +368,6 @@ BEGIN
     RETURN result;
 END;
 
-PROCEDURE Ops.is(cx: ContextHierarchy.Node): ExpressionTree.BinaryOperatorCx;
-VAR
-    impl: ExpressionTree.BinaryOperatorCx;
-    r: ExpressionTree.BinaryOperatorCx;
-
-    PROCEDURE is(left, right: Expression.PType; lcx: LanguageContext.PType): Expression.PType;
-    BEGIN
-        d <- left.designator();
-        IF d # NIL THEN
-            v <- d.info();
-            IF v IS EberonTypePromotion.PVariable THEN
-                msg <- EberonContextDesignator.PromoteTypeMsg(
-                            v, 
-                            ExpressionTree.unwrapType(right.designator().info()));
-                void <- cx.handleMessage(msg);
-            END;
-        END;
-        RETURN impl(left, right, lcx);
-    END;
-BEGIN
-    impl := SUPER(cx);
-    JS.do("r = is"); (*allow closure*)
-    RETURN r;
-END;
-
 PROCEDURE Ops.coalesceType(leftType, rightType: Types.PType): Types.PType;
 VAR
     result: Types.PType;
@@ -428,9 +392,22 @@ END;
 
 PROCEDURE Node.addSimple(s: ExpressionTree.PSimpleList);
 BEGIN
-    typePromotion <- s(PSimpleList).typePromotion;
-    IF typePromotion # NIL THEN
-        SELF.currentTypePromotion := typePromotion;
+    SELF.combinedTypePromotion := s(PSimpleList).typePromotion;
+
+    IF (SELF.left # NIL) & (SELF.right.op = "IS") THEN
+        d <- SELF.left.term.factor.expression.designator();
+        IF d # NIL THEN
+            v <- d.info();
+            IF v IS EberonTypePromotion.PVariable THEN
+                type <- ExpressionTree.unwrapType(s.term.factor.expression.designator().info());
+                IF SELF.parentTerm = NIL THEN
+                    SELF.varTypePromotion := NEW EberonTypePromotion.ForVariable(v, type, FALSE);
+                ELSE
+                    p <- setTermTypePromotion(SELF.parentTerm^);
+                    p.promote(v, type);
+                END;
+            END;
+        END;
     END;
 
     SUPER(s);
@@ -438,8 +415,8 @@ END;
 
 PROCEDURE Node.addOp(op: STRING);
 BEGIN
-    IF SELF.currentTypePromotion # NIL THEN
-        SELF.currentTypePromotion.clear();
+    IF SELF.combinedTypePromotion # NIL THEN
+        SELF.combinedTypePromotion.clear();
     END;
 
     SUPER(op);

src/eberon/EberonContextTypePromotion.ob

@@ -23,10 +23,6 @@ BEGIN
     IF SELF.ignorePromotions THEN
     ELSIF msg IS EberonContextDesignator.TransferPromotedTypesMsg THEN
         result := TRUE;
-    ELSIF msg IS EberonContextDesignator.PromoteTypeMsg THEN
-        SELF.typePromotion := NEW EberonTypePromotion.ForVariable(msg.info, msg.type, FALSE);
-        SELF.typePromotions.add(SELF.typePromotion);
-        result := TRUE;
     ELSIF msg IS EberonContextExpression.ExpressionTypePromotion THEN
         SELF.typePromotion := msg.typePromotion;
         SELF.typePromotions.add(SELF.typePromotion);

src/ob/ExpressionTree.ob

@@ -14,7 +14,7 @@ TYPE
         PROCEDURE greater*(type: Types.PType): BinaryOperatorCx;
         PROCEDURE lessEq*(type: Types.PType): BinaryOperatorCx;
         PROCEDURE greaterEq*(type: Types.PType): BinaryOperatorCx;
-        PROCEDURE is*(cx: ContextHierarchy.Node): BinaryOperatorCx;
+        PROCEDURE is*(VAR cx: ContextHierarchy.Node): BinaryOperatorCx;
         PROCEDURE in*(left, right: Types.PType; cx: ContextHierarchy.Node): BinaryOperatorCx;
         PROCEDURE plus*(type: Types.PType): BinaryOperator;
 
@@ -37,7 +37,7 @@ TYPE
 
     PTermItemOp = POINTER TO TermItemOp;
     TermItem* = RECORD
-        factor: PFactor;
+        factor-: PFactor;
         next: PTermItemOp;
     END;
 
@@ -57,8 +57,8 @@ TYPE
     PTermList* = POINTER TO TermList;
 
     PSimpleItemOp = POINTER TO SimpleItemOp;
-    SimpleItem = RECORD
-        term: PTermList;
+    SimpleItem* = RECORD
+        term-: PTermList;
         next: PSimpleItemOp;
     END;
 
@@ -78,12 +78,7 @@ TYPE
     END;
     PSimpleList* = POINTER TO SimpleList;
 
-    Item = RECORD
-        simple: PSimpleList;
-        next: POINTER TO ItemOp; 
-    END;
-
-    Node* = RECORD (Item)
+    Node* = RECORD
     	PROCEDURE Node*(ops: POps);
 
     	PROCEDURE makeSimple*(): PSimpleList;
@@ -92,14 +87,16 @@ TYPE
     	PROCEDURE asExpression*(cx: ContextHierarchy.PNode): Expression.PType;
 
     	ops: POps;
-        last: POINTER TO ItemOp;
+        left-: PSimpleList;
+        right-: POINTER TO RightNode;
     END;
     PNode* = POINTER TO Node;
 
-    ItemOp = RECORD (Item)
-        PROCEDURE ItemOp(op: STRING);
+    RightNode* = RECORD
+        PROCEDURE RightNode(op: STRING);
 
-        op: STRING;
+        op-: STRING;
+        simple: PSimpleList;
     END;
 
     OpTypeCheck = RECORD
@@ -325,7 +322,7 @@ BEGIN
     RETURN result;
 END;
 
-PROCEDURE relationOp(left, right: Expression.PType; literal: STRING; ops: Ops; context: ContextHierarchy.Node): BinaryOperatorCx;
+PROCEDURE relationOp(left, right: Expression.PType; literal: STRING; ops: Ops; VAR context: ContextHierarchy.Node): BinaryOperatorCx;
 VAR
     type: Types.PType;
     o: BinaryOperatorCx;
@@ -500,21 +497,19 @@ BEGIN
     RETURN result;
 END;
 
-PROCEDURE makeFromList(list: Item; ops: Ops; cx: ContextHierarchy.PNode): Expression.PType;
+PROCEDURE makeFromNode(node: Node; ops: Ops; cx: ContextHierarchy.PNode): Expression.PType;
 BEGIN
     root <- cx.root();
-    result <- makeFromSimpleList(list.simple^, ops, root^);
-    next <- list.next;
-    WHILE next # NIL DO
+    result <- makeFromSimpleList(node.left^, ops, root^);
+    right <- node.right;
+    IF right # NIL THEN
         leftExpression <- result;
-        rightExpression <- makeFromSimpleList(next.simple^, ops, root^);
+        rightExpression <- makeFromSimpleList(right.simple^, ops, root^);
         leftExpression := promoteTypeInExpression(leftExpression, rightExpression.type());
         rightExpression := promoteTypeInExpression(rightExpression, leftExpression.type());
 
-        o <- relationOp(leftExpression, rightExpression, next.op, ops, cx^);
+        o <- relationOp(leftExpression, rightExpression, right.op, ops, cx^);
         result := o(leftExpression, rightExpression, ContextHierarchy.makeLanguageContext(cx));
-
-        next := next.next;
     END;
     notTypeId(result);
 
@@ -525,7 +520,7 @@ BEGIN
     RETURN result;
 END;
 
-PROCEDURE Ops.is(cx: ContextHierarchy.Node): BinaryOperatorCx;
+PROCEDURE Ops.is(VAR cx: ContextHierarchy.Node): BinaryOperatorCx;
 VAR
     r: BinaryOperatorCx;
 
@@ -717,7 +712,7 @@ PROCEDURE SimpleItemOp.SimpleItemOp(op: STRING)
     | op(op);
 END;
 
-PROCEDURE ItemOp.ItemOp(op: STRING)
+PROCEDURE RightNode.RightNode(op: STRING)
     | op(op);
 END;
 
@@ -779,26 +774,20 @@ END;
 
 PROCEDURE Node.addSimple(s: PSimpleList);
 BEGIN
-    IF SELF.simple = NIL THEN
-        SELF.simple := s;
+    IF SELF.left = NIL THEN
+        SELF.left := s;
     ELSE
-        SELF.last.simple := s;
+        SELF.right.simple := s;
     END;
 END;
 
 PROCEDURE Node.addOp(op: STRING);
 BEGIN
-    next <- NEW ItemOp(op);
-    IF SELF.last = NIL THEN
-        SELF.next := next;
-    ELSE
-        SELF.last.next := next;
-    END;
-    SELF.last := next;
+    SELF.right := NEW RightNode(op);
 END;
 
 PROCEDURE Node.asExpression(cx: ContextHierarchy.PNode): Expression.PType;
-	RETURN makeFromList(SELF, SELF.ops^, cx);
+	RETURN makeFromNode(SELF, SELF.ops^, cx);
 END;
 
 PROCEDURE IntOpTypeCheck.expect(): STRING;