Add TODO markers

Author: Lotes

packages/language/src/typesystem/arithmetic-operations.ts

@@ -10,7 +10,7 @@ type ArithmeticTypeRule = {
     when: BinaryOperatorPredicate;
     then: ComputeOperationReturnType;
 };
-type ArithmeticOperator = '+' | '-' | '*' | '/' | '**';
+export type ArithmeticOperator = '+' | '-' | '*' | '/' | '**';
 
 /** Approximation of ln(10)/ln(2) */
 export const DecimalToBinaryDigitsFactor = 3.32;

packages/language/src/typesystem/infer.ts

@@ -1,6 +1,7 @@
 import { assertUnreachable } from "langium";
 import { isExpression, isNumberLiteral, isStringLiteral, Pl1AstType } from "../generated/ast";
 import { TypesDescriptions } from "./descriptions";
+import { ArithmeticOperator, createArithmeticOperationTable } from "./arithmetic-operations";
 
 export type PliAstNode = Pl1AstType[keyof Pl1AstType];
 
@@ -9,63 +10,90 @@ export interface PliTypeInferer {
 }
 
 export class DefaultPliTypeInferer implements PliTypeInferer {
+    private inferArithmeticOperation: ({ op, lhs, rhs }: { op: ArithmeticOperator; lhs: TypesDescriptions.Arithmetic; rhs: TypesDescriptions.Arithmetic; }) => TypesDescriptions.Any | undefined;
+    constructor() {
+        /** @todo pass in the compiler flag RULES(X), where X = 'ans' or 'ibm' */
+        this.inferArithmeticOperation = createArithmeticOperationTable('ans');
+    }
     /** @todo multiple entry points: for Expression, VariableDecl, Entries? */
     inferType(node: PliAstNode): TypesDescriptions.Any | undefined {
         if (isExpression(node)) {
             switch (node.$type) {
                 case "BinaryExpression":
-                    //@see https://www.ibm.com/docs/en/epfz/6.1?topic=operations-results-arithmetic
                     switch (node.op) {
-                        case "!!":
-                        case "&":
-                        case "*":
-                        case "**":
                         case "+":
                         case "-":
+                        case "*":
                         case "/":
+                        case "**": {
+                            //@see https://www.ibm.com/docs/en/epfz/6.1?topic=operations-results-arithmetic
+                            const op = node.op;
+                            const lhs = this.inferType(node.left);
+                            const rhs = this.inferType(node.right);
+                            if (!lhs || !rhs || !TypesDescriptions.isArithmetic(lhs) || !TypesDescriptions.isArithmetic(rhs)) {
+                                /** @todo also take care of this branch */
+                                return undefined;
+                            }
+                            return this.inferArithmeticOperation({ op, lhs, rhs })
+                        }
+                        case "<":
+                        case "<=":
+                        case "<>":
+                        case "=":
+                        case ">":
+                        case ">=": {
+                            return TypesDescriptions.Boolean;
+                        }
                         case "^":
+                        case "!!":
+                        case "&":
                         case "^=":
                         case "|":
                         case "||":
                         case "¬":
                         case "¬<":
                         case "¬=":
-                        case "¬>":
-                            break;
-                        case "<":
-                        case "<=":
-                        case "<>":
-                        case "=":
-                        case ">":
-                        case ">=":
-                            return TypesDescriptions.Boolean;
+                        case "¬>": {
+                            /** @todo */
+                            return undefined;
+                        }
                         default:
                             assertUnreachable(node)
                     }
-                    break;
                 case "UnaryExpression":
                     switch (node.op) {
                         case "+":
-                        case "-":
-                        case "^":
-                        case "¬":
-                            break;
+                        case "-": {
+                            /** @todo what about negating vs. sign of the type */
+                            return this.inferType(node.expr);
+                        }
+                        case "^": {
+                            /** @todo */
+                            return undefined;
+                        }
+                        case "¬": {
+                            return TypesDescriptions.Boolean;
+                        }
                         default:
                             assertUnreachable(node)
                     }
-                    break;
                 case "Literal":
                     if (isStringLiteral(node.value)) {
-
+                        /** @todo */
+                        return undefined;
                     } else if (isNumberLiteral(node.value)) {
-
+                        /** @todo */
+                        return undefined;
                     } else {
                         assertUnreachable(node.value);
                     }
-                    break;
-                case "LocatorCall":
+                case "LocatorCall": {
                     //node.previous -> node.element
-                    break;
+                    /** @todo */
+                    return undefined;
+                }
+                default:
+                    assertUnreachable(node);
             }
         }
         return undefined;