iVProg/js/processor/semantic/semanticAnalyser.js

import { ProcessorErrorFactory } from "./../error/processorErrorFactory";
import { LanguageDefinedFunction } from "./../definedFunctions";
import { LanguageService } from "./../../services/languageService";
import {
  ArrayDeclaration,
  While,
  For,
  Switch,
  Assign,
  Break,
  IfThenElse,
  Return,
  ArrayIndexAssign,
} from "../../ast/commands";
// eslint-disable-next-line @typescript-eslint/no-unused-vars
import { Expression } from "./../../ast/expressions/expression";
import {
  InfixApp,
  UnaryApp,
  FunctionCall,
  IntLiteral,
  RealLiteral,
  StringLiteral,
  BoolLiteral,
  VariableLiteral,
  ArrayAccess,
  CharLiteral,
} from "../../ast/expressions";
import { Literal } from "../../ast/expressions/literal";
import {
  resultTypeAfterInfixOp,
  resultTypeAfterUnaryOp,
} from "../compatibilityTable";
import { Types } from "../../typeSystem/types";
import { ArrayType } from "../../typeSystem/array_type";
import { MultiType } from "../../typeSystem/multiType";
import { Config } from "../../util/config";
import { Store } from "../store/store";
import { IVProgParser } from "../../ast/ivprogParser";

export class SemanticAnalyser {
  static analyseFromSource (stringCode) {
    const parser = IVProgParser.createParser(stringCode);
    const semantic = new SemanticAnalyser(parser.parseTree());
    return semantic.analyseTree();
  }

  constructor (ast) {
    this.ast = ast;
    this.lexerClass = LanguageService.getCurrentLexer();
    const lexer = new this.lexerClass(null);
    this.literalNames = lexer.literalNames;
    this.symbolMap = null;
    this.currentFunction = null;
  }

  pushMap () {
    if (this.symbolMap === null) {
      this.symbolMap = { map: {}, next: null };
    } else {
      const n = { map: {}, next: this.symbolMap };
      this.symbolMap = n;
    }
  }

  popMap () {
    if (this.symbolMap !== null) {
      this.symbolMap = this.symbolMap.next;
    }
  }

  insertSymbol (id, typeInfo) {
    this.symbolMap.map[id] = typeInfo;
  }

  findSymbol (id, symbol_map) {
    if (!symbol_map.map[id]) {
      if (symbol_map.next) {
        return this.findSymbol(id, symbol_map.next);
      }
      return null;
    } else {
      return symbol_map.map[id];
    }
  }

  getMainFunction () {
    return this.ast.functions.find((v) => v.isMain);
  }

  findFunction (name) {
    if (name.match(/^\$.+$/)) {
      const fun = LanguageDefinedFunction.getFunction(name);
      if (!fun) {
        throw ProcessorErrorFactory.not_implemented(name);
      }
      return fun;
    } else {
      const val = this.ast.functions.find((v) => v.name === name);
      if (!val) {
        return null;
      }
      return val;
    }
  }

  analyseTree () {
    const globalVars = this.ast.global;
    this.pushMap();
    this.assertDeclarations(globalVars);
    const functions = this.ast.functions;
    const mainFunc = functions.filter((f) => f.name === null);
    if (mainFunc.length <= 0) {
      throw ProcessorErrorFactory.main_missing();
    }
    for (let i = 0; i < functions.length; i++) {
      const fun = functions[i];
      this.assertFunction(fun);
    }
    return this.ast;
  }

  assertDeclarations (list) {
    for (let i = 0; i < list.length; i++) {
      this.assertDeclaration(list[i]);
    }
  }

  assertDeclaration (declaration) {
    if (declaration instanceof ArrayDeclaration) {
      this.assertArrayDeclaration(declaration);
      this.insertSymbol(declaration.id, {
        id: declaration.id,
        lines: declaration.lines,
        columns: declaration.columns,
        type: declaration.type,
        isConst: declaration.isConst,
      });
    } else {
      if (declaration.initial === null) {
        this.insertSymbol(declaration.id, {
          id: declaration.id,
          type: declaration.type,
          isConst: declaration.isConst,
        });
        return;
      }
      const resultType = this.evaluateExpressionType(declaration.initial);
      if (resultType instanceof MultiType) {
        if (!resultType.isCompatible(declaration.type)) {
          const stringInfo = declaration.type.stringInfo();
          const info = stringInfo[0];
          const result_string_info = resultType.stringInfo();
          const result_info = result_string_info[0];
          const exp = declaration.initial;
          throw ProcessorErrorFactory.incompatible_types_full(
            info.type,
            info.dim,
            result_info.type,
            result_info.dim,
            exp.toString(),
            declaration.sourceInfo
          );
        }
        this.insertSymbol(declaration.id, {
          id: declaration.id,
          type: declaration.type,
          isConst: declaration.isConst,
        });
      } else if (
        (!declaration.type.isCompatible(resultType) &&
          !Config.enable_type_casting) ||
        (!declaration.type.isCompatible(resultType) &&
          Config.enable_type_casting &&
          !Store.canImplicitTypeCast(declaration.type, resultType))
      ) {
        const stringInfo = declaration.type.stringInfo();
        const info = stringInfo[0];
        const result_string_info = resultType.stringInfo();
        const result_info = result_string_info[0];
        const exp = declaration.initial;
        throw ProcessorErrorFactory.incompatible_types_full(
          info.type,
          info.dim,
          result_info.type,
          result_info.dim,
          exp.toString(),
          declaration.sourceInfo
        );
      } else {
        this.insertSymbol(declaration.id, {
          id: declaration.id,
          type: declaration.type,
          isConst: declaration.isConst,
        });
      }
    }
  }

  assertArrayDeclaration (declaration) {
    if (declaration.initial === null) {
      const lineType = this.evaluateExpressionType(declaration.lines);
      if (!lineType.isCompatible(Types.INTEGER)) {
        throw ProcessorErrorFactory.array_dimension_not_int_full(
          declaration.sourceInfo
        );
      }
      if (declaration.columns !== null) {
        const columnType = this.evaluateExpressionType(declaration.columns);
        if (!columnType.isCompatible(Types.INTEGER)) {
          throw ProcessorErrorFactory.array_dimension_not_int_full(
            declaration.sourceInfo
          );
        }
      }
    } else {
      this.evaluateArrayLiteral(declaration);
    }
    this.insertSymbol(declaration.id, {
      id: declaration.id,
      lines: declaration.lines,
      columns: declaration.columns,
      type: declaration.type,
    });
    return;
  }

  evaluateExpressionType (expression) {
    // TODO: Throw operator error in case type == UNDEFINED
    if (expression instanceof UnaryApp) {
      const op = expression.op;
      const resultType = this.evaluateExpressionType(expression.left);
      const finalResult = resultTypeAfterUnaryOp(op, resultType);
      if (Types.UNDEFINED.isCompatible(finalResult)) {
        const stringInfo = resultType.stringInfo();
        const info = stringInfo[0];
        const expString = expression.toString();
        throw ProcessorErrorFactory.invalid_unary_op_full(
          expString,
          op,
          info.type,
          info.dim,
          expression.sourceInfo
        );
      }
      return finalResult;
    } else if (expression instanceof InfixApp) {
      const op = expression.op;
      const resultTypeLeft = this.evaluateExpressionType(expression.left);
      const resultTypeRight = this.evaluateExpressionType(expression.right);
      const finalResult = resultTypeAfterInfixOp(
        op,
        resultTypeLeft,
        resultTypeRight
      );
      if (Types.UNDEFINED.isCompatible(finalResult)) {
        const stringInfoLeft = resultTypeLeft.stringInfo();
        const infoLeft = stringInfoLeft[0];
        const stringInfoRight = resultTypeRight.stringInfo();
        const infoRight = stringInfoRight[0];
        const expString = expression.toString();
        throw ProcessorErrorFactory.invalid_infix_op_full(
          expString,
          op,
          infoLeft.type,
          infoLeft.dim,
          infoRight.type,
          infoRight.dim,
          expression.sourceInfo
        );
      }
      return finalResult;
    } else if (expression instanceof Literal) {
      return this.evaluateLiteralType(expression);
    } else if (expression instanceof FunctionCall) {
      if (expression.isMainCall) {
        throw ProcessorErrorFactory.void_in_expression_full(
          LanguageDefinedFunction.getMainFunctionName(),
          expression.sourceInfo
        );
      }
      const fun = this.findFunction(expression.id);
      if (fun === null) {
        throw ProcessorErrorFactory.function_missing_full(
          expression.id,
          expression.sourceInfo
        );
      }
      if (fun.returnType.isCompatible(Types.VOID)) {
        throw ProcessorErrorFactory.void_in_expression_full(
          expression.id,
          expression.sourceInfo
        );
      }
      this.assertParameters(fun, expression.actualParameters);
      return fun.returnType;
    } else if (expression instanceof ArrayAccess) {
      const arrayTypeInfo = this.findSymbol(expression.id, this.symbolMap);
      if (arrayTypeInfo === null) {
        throw ProcessorErrorFactory.symbol_not_found_full(
          expression.id,
          expression.sourceInfo
        );
      }
      if (!(arrayTypeInfo.type instanceof ArrayType)) {
        throw ProcessorErrorFactory.invalid_array_access_full(
          expression.id,
          expression.sourceInfo
        );
      }
      const lineType = this.evaluateExpressionType(expression.line);
      if (!lineType.isCompatible(Types.INTEGER)) {
        throw ProcessorErrorFactory.array_dimension_not_int_full(
          expression.sourceInfo
        );
      }
      if (expression.column !== null) {
        if (arrayTypeInfo.columns === null) {
          throw ProcessorErrorFactory.invalid_matrix_access_full(
            expression.id,
            expression.sourceInfo
          );
        }
        const columnType = this.evaluateExpressionType(expression.column);
        if (!columnType.isCompatible(Types.INTEGER)) {
          throw ProcessorErrorFactory.array_dimension_not_int_full(
            expression.sourceInfo
          );
        }
      }
      const arrType = arrayTypeInfo.type;
      if (expression.column !== null) {
        // indexing matrix
        return arrType.innerType;
      } else {
        if (arrayTypeInfo.columns === null) {
          return arrType.innerType;
        }
        return new ArrayType(arrType.innerType, 1);
      }
    }
  }

  evaluateLiteralType (literal) {
    if (literal instanceof IntLiteral) {
      return literal.type;
    } else if (literal instanceof RealLiteral) {
      return literal.type;
    } else if (literal instanceof StringLiteral) {
      return literal.type;
    } else if (literal instanceof BoolLiteral) {
      return literal.type;
    } else if (literal instanceof CharLiteral) {
      return literal.type;
    } else if (literal instanceof VariableLiteral) {
      const typeInfo = this.findSymbol(literal.id, this.symbolMap);
      if (typeInfo === null) {
        throw ProcessorErrorFactory.symbol_not_found_full(
          literal.id,
          literal.sourceInfo
        );
      }
      if (typeInfo.type instanceof ArrayType) {
        return typeInfo.type;
      }
      return typeInfo.type;
    } else {
      // console.warn("Evaluating type only for an array literal...");
      let last = null;
      if (literal.value.length === 1) {
        last = this.evaluateExpressionType(literal.value[0]);
      } else {
        for (let i = 0; i < literal.value.length; i++) {
          const e = this.evaluateExpressionType(literal.value[i]);
          if (last === null) {
            last = e;
          } else if (!last.isCompatible(e)) {
            const strInfo = last.stringInfo();
            const info = strInfo[0];
            const strExp = literal.toString();
            throw ProcessorErrorFactory.incompatible_types_array_full(
              strExp,
              info.type,
              info.dim,
              literal.sourceInfo
            );
          }
        }
      }
      if (last instanceof ArrayType) {
        return new ArrayType(last.innerType, last.dimensions + 1);
      }
      return new ArrayType(last, 1);
    }
  }

  evaluateArrayLiteral (arrayDeclaration) {
    const type = arrayDeclaration.type;
    const literal = arrayDeclaration.initial;
    // console.log(arrayDeclaration);
    if (arrayDeclaration.isVector) {
      this.evaluateVectorLiteralType(literal, type);
    } else {
      // TODO matrix type check
      for (let i = 0; i < literal.lines; ++i) {
        const line_literal = literal.value[i];
        this.evaluateVectorLiteralType(
          line_literal,
          new ArrayType(type.innerType, 1)
        );
      }
    }
    return true;
  }

  assertFunction (fun) {
    this.pushMap();
    this.currentFunction = fun;
    fun.formalParameters.forEach((formalParam) => {
      if (formalParam.type instanceof ArrayType) {
        if (formalParam.type.dimensions > 1) {
          this.insertSymbol(formalParam.id, {
            id: formalParam.id,
            lines: -1,
            columns: -1,
            type: formalParam.type,
          });
        } else {
          this.insertSymbol(formalParam.id, {
            id: formalParam.id,
            lines: -1,
            columns: null,
            type: formalParam.type,
          });
        }
      } else {
        this.insertSymbol(formalParam.id, {
          id: formalParam.id,
          type: formalParam.type,
        });
      }
    });
    this.assertDeclarations(fun.variablesDeclarations);
    const optional = fun.returnType.isCompatible(Types.VOID);
    const valid = this.assertReturn(fun, optional);
    if (!valid) {
      throw ProcessorErrorFactory.function_no_return(fun.name);
    }
    this.popMap();
  }

  assertReturn (fun, optional) {
    return fun.commands.reduce(
      (last, next) => this.checkCommand(fun.returnType, next, optional) || last,
      optional
    );
  }

  checkCommand (type, cmd, optional) {
    if (cmd instanceof While) {
      const resultType = this.evaluateExpressionType(cmd.expression);
      if (!resultType.isCompatible(Types.BOOLEAN)) {
        throw ProcessorErrorFactory.loop_condition_type_full(
          cmd.expression.toString(),
          cmd.sourceInfo
        );
      }
      this.checkCommands(type, cmd.commands, optional);
      return false;
    } else if (cmd instanceof For) {
      const var_type = this.evaluateExpressionType(cmd.for_id);
      if (!var_type.isCompatible(Types.INTEGER)) {
        throw ProcessorErrorFactory.invalid_for_variable(
          cmd.for_id,
          cmd.sourceInfo
        );
      }
      const from_type = this.evaluateExpressionType(cmd.for_from);
      if (!from_type.isCompatible(Types.INTEGER)) {
        throw ProcessorErrorFactory.invalid_for_from(
          cmd.for_from,
          cmd.sourceInfo
        );
      }
      const to_type = this.evaluateExpressionType(cmd.for_to);
      if (!to_type.isCompatible(Types.INTEGER)) {
        throw ProcessorErrorFactory.invalid_for_to(cmd.for_to, cmd.sourceInfo);
      }
      if (cmd.for_pass != null) {
        const pass_type = this.evaluateExpressionType(cmd.for_pass);
        if (!pass_type.isCompatible(Types.INTEGER)) {
          throw ProcessorErrorFactory.invalid_for_pass(
            cmd.for_pass,
            cmd.sourceInfo
          );
        }
      }
      this.checkCommands(type, cmd.commands, optional);
      return false;
    } else if (cmd instanceof Switch) {
      const sType = this.evaluateExpressionType(cmd.expression);
      let result = optional;
      let hasDefault = false;
      for (let i = 0; i < cmd.cases.length; i++) {
        const aCase = cmd.cases[i];
        if (aCase.expression !== null) {
          const caseType = this.evaluateExpressionType(aCase.expression);
          if (!sType.isCompatible(caseType)) {
            const strInfo = sType.stringInfo();
            const info = strInfo[0];
            const strExp = aCase.expression.toString();
            throw ProcessorErrorFactory.invalid_case_type_full(
              strExp,
              info.type,
              info.dim,
              aCase.sourceInfo
            );
          }
        } else {
          hasDefault = true;
        }
        result = result && this.checkCommands(type, aCase.commands, result);
      }
      return result && hasDefault;
    } else if (cmd instanceof ArrayIndexAssign) {
      // TODO - rework!!!!!
      let used_dims = 0;
      const typeInfo = this.findSymbol(cmd.id, this.symbolMap);
      if (typeInfo === null) {
        throw ProcessorErrorFactory.symbol_not_found_full(
          cmd.id,
          cmd.sourceInfo
        );
      }
      if (typeInfo.isConst) {
        throw ProcessorErrorFactory.invalid_const_assignment_full(
          cmd.id,
          cmd.sourceInfo
        );
      }
      if (!(typeInfo.type instanceof ArrayType)) {
        throw ProcessorErrorFactory.invalid_array_access_full(
          cmd.id,
          cmd.sourceInfo
        );
      }
      const exp = cmd.expression;
      const lineExp = cmd.line;
      const lineType = this.evaluateExpressionType(lineExp);
      if (!lineType.isCompatible(Types.INTEGER)) {
        throw ProcessorErrorFactory.array_dimension_not_int_full(
          cmd.sourceInfo
        );
      }
      used_dims += 1;
      const columnExp = cmd.column;
      if (typeInfo.columns === null && columnExp !== null) {
        throw ProcessorErrorFactory.invalid_matrix_access_full(
          cmd.id,
          cmd.sourceInfo
        );
      } else if (columnExp !== null) {
        const columnType = this.evaluateExpressionType(columnExp);
        if (!columnType.isCompatible(Types.INTEGER)) {
          throw ProcessorErrorFactory.array_dimension_not_int_full(
            cmd.sourceInfo
          );
        }
        used_dims += 1;
      }
      // exp a single value exp or an array access
      const exp_type = this.evaluateExpressionType(exp);
      const access_type = typeInfo.type;

      let compatible = false;
      let type = access_type;
      if (exp_type instanceof MultiType) {
        if (access_type.dimensions - used_dims == 0) {
          type = access_type.innerType;
        } else {
          type = new ArrayType(
            access_type.innerType,
            Math.max(0, access_type.dimensions - used_dims)
          );
        }
        compatible = exp_type.isCompatible(type);
      } else {
        compatible = access_type.canAccept(exp_type, used_dims);
      }
      if (!compatible) {
        if (0 === access_type.dimensions - used_dims) {
          type = access_type.innerType; // enable a valid attempt to cast real <--> integer
        }
        if (
          !Config.enable_type_casting ||
          !Store.canImplicitTypeCast(type, exp_type)
        ) {
          const access_type_string_info = access_type.stringInfo();
          const access_type_info = access_type_string_info[0];
          const exp_type_string_info = exp_type.stringInfo();
          const exp_type_info = exp_type_string_info[0];
          throw ProcessorErrorFactory.incompatible_types_full(
            access_type_info.type,
            access_type_info.dim - used_dims,
            exp_type_info.type,
            exp_type_info.dim,
            exp.toString(),
            cmd.sourceInfo
          );
        }
      }
      return optional;
    } else if (cmd instanceof Assign) {
      // TODO - rework since there is no literal array assignment
      const typeInfo = this.findSymbol(cmd.id, this.symbolMap);
      if (typeInfo === null) {
        throw ProcessorErrorFactory.symbol_not_found_full(
          cmd.id,
          cmd.sourceInfo
        );
      }
      if (typeInfo.isConst) {
        throw ProcessorErrorFactory.invalid_const_assignment_full(
          cmd.id,
          cmd.sourceInfo
        );
      }
      const exp = cmd.expression;
      const exp_type = this.evaluateExpressionType(exp);
      if (exp_type instanceof ArrayType) {
        if (!(typeInfo.type instanceof ArrayType)) {
          // TODO better error message
          throw new Error("Cannot assign an array to a non-array variable ");
        }
        // Both are arrays...
        // if both don't have same dimensions and type, cannot perform assignment
        if (!exp_type.isCompatible(typeInfo.type)) {
          if (
            exp_type.dimensions === typeInfo.type.dimensions &&
            !exp_type.innerType.isCompatible(typeInfo.type.innerType)
          ) {
            if (
              !Config.enable_type_casting ||
              !Store.canImplicitTypeCast(
                typeInfo.type.innerType,
                exp_type.innerType
              )
            ) {
              const stringInfo = typeInfo.type.stringInfo();
              const info = stringInfo[0];
              const exp_type_string_info = exp_type.stringInfo();
              const exp_type_info = exp_type_string_info[0];
              throw ProcessorErrorFactory.incompatible_types_full(
                info.type,
                info.dim,
                exp_type_info.type,
                exp_type_info.dim,
                exp.toString(),
                cmd.sourceInfo
              );
            }
          } else {
            switch (exp_type.dimensions) {
              case 1: {
                throw ProcessorErrorFactory.vector_to_matrix_attr(
                  cmd.id,
                  exp.toString(),
                  cmd.sourceInfo
                );
              }
              case 2: {
                throw ProcessorErrorFactory.matrix_to_vector_attr(
                  cmd.id,
                  exp.toString(),
                  cmd.sourceInfo
                );
              }
            }
          }
        }
      } else if (!exp_type.isCompatible(typeInfo.type)) {
        if (
          !Config.enable_type_casting ||
          !Store.canImplicitTypeCast(typeInfo.type, exp_type)
        ) {
          const stringInfo = typeInfo.type.stringInfo();
          const info = stringInfo[0];
          const exp_type_string_info = exp_type.stringInfo();
          const exp_type_info = exp_type_string_info[0];
          throw ProcessorErrorFactory.incompatible_types_full(
            info.type,
            info.dim,
            exp_type_info.type,
            exp_type_info.dim,
            exp.toString(),
            cmd.sourceInfo
          );
        }
      }
      return optional;
    } else if (cmd instanceof Break) {
      return optional;
    } else if (cmd instanceof IfThenElse) {
      const resultType = this.evaluateExpressionType(cmd.condition);
      if (!resultType.isCompatible(Types.BOOLEAN)) {
        throw ProcessorErrorFactory.if_condition_type_full(
          cmd.condition.toString(),
          cmd.sourceInfo
        );
      }
      if (cmd.ifFalse instanceof IfThenElse) {
        return (
          this.checkCommands(type, cmd.ifTrue.commands, optional) &&
          this.checkCommand(type, cmd.ifFalse, optional)
        );
      } else if (cmd.ifFalse != null) {
        return (
          this.checkCommands(type, cmd.ifTrue.commands, optional) &&
          this.checkCommands(type, cmd.ifFalse.commands, optional)
        );
      } else {
        return this.checkCommands(type, cmd.ifTrue.commands, optional);
      }
    } else if (cmd instanceof FunctionCall) {
      let fun = null;
      if (cmd.isMainCall) {
        fun = this.getMainFunction();
      } else {
        fun = this.findFunction(cmd.id);
      }
      if (fun === null) {
        throw ProcessorErrorFactory.function_missing_full(
          cmd.id,
          cmd.sourceInfo
        );
      }
      this.assertParameters(fun, cmd.actualParameters);
      return optional;
    } else if (cmd instanceof Return) {
      const funcName = this.currentFunction.isMain
        ? LanguageDefinedFunction.getMainFunctionName()
        : this.currentFunction.name;
      if (cmd.expression === null && !type.isCompatible(Types.VOID)) {
        const stringInfo = type.stringInfo();
        const info = stringInfo[0];
        throw ProcessorErrorFactory.invalid_void_return_full(
          funcName,
          info.type,
          info.dim,
          cmd.sourceInfo
        );
      } else if (cmd.expression !== null) {
        const resultType = this.evaluateExpressionType(cmd.expression);
        if (!type.isCompatible(resultType)) {
          if (
            !Config.enable_type_casting ||
            !Store.canImplicitTypeCast(type, resultType)
          ) {
            const stringInfo = type.stringInfo();
            const info = stringInfo[0];
            throw ProcessorErrorFactory.invalid_return_type_full(
              funcName,
              info.type,
              info.dim,
              cmd.sourceInfo
            );
          }
        }
        return true;
      } else {
        return true;
      }
    }
  }

  checkCommands (type, cmds, optional) {
    return cmds.reduce(
      (last, next) => this.checkCommand(type, next, optional) || last,
      optional
    );
  }

  /**
   *
   * @param {import('./../../ast/commands/function').Function} fun
   * @param {Expression[]} actualParametersList
   */
  assertParameters (fun, actualParametersList) {
    const parameterList = fun.formalParameters;
    if (
      parameterList.length > actualParametersList.length ||
      (parameterList.length !== actualParametersList.length &&
        !fun.hasVariadic())
    ) {
      throw ProcessorErrorFactory.invalid_parameters_size_full(
        fun.name,
        actualParametersList.length,
        fun.formalParameters.length,
        null
      );
    }

    for (
      let i = 0, j = 0;
      i < parameterList.length && j < actualParametersList.length;
      i += 1, j += 1
    ) {
      const formalParam = parameterList[i];
      if (formalParam.variadic && i + 1 !== parameterList.length) {
        throw "A function variadic parameter must be its last parameter!";
      }
      if (formalParam.variadic) {
        j = this.assertVariadicParameter(
          fun,
          formalParam,
          j,
          actualParametersList
        );
      } else {
        const param = actualParametersList[j];
        this.assertParameter(fun, formalParam, param);
      }
    }
  }

  evaluateVectorLiteralType (literal, type) {
    // console.log(literal);
    for (let i = 0; i < literal.value.length; i += 1) {
      const exp = literal.value[i];
      const expType = this.evaluateExpressionType(exp);
      let compatible = false;
      if (expType instanceof MultiType) {
        compatible = expType.isCompatible(type.innerType);
      } else {
        compatible = type.canAccept(expType, 1);
      }
      if (!compatible) {
        if (
          !Config.enable_type_casting ||
          !Store.canImplicitTypeCast(type.innerType, expType)
        ) {
          const stringInfo = type.stringInfo();
          const info = stringInfo[0];
          const result_string_info = expType.stringInfo();
          const result_info = result_string_info[0];
          throw ProcessorErrorFactory.incompatible_types_full(
            info.type,
            0,
            result_info.type,
            result_info.dim,
            exp.toString(),
            literal.sourceInfo
          );
        }
      }
    }
    return type;
  }

  /**
   *
   * @param {import('./../../ast/commands/function').Function} fun
   * @param {import('./../../ast/commands/formalParameter').FormalParameter} formalParam
   * @param {number} index
   * @param {Expression[]} actualParametersList
   */
  assertVariadicParameter (fun, formalParam, index, actualParametersList) {
    let i;
    for (i = index; i < actualParametersList.length; i += 1) {
      this.assertParameter(fun, formalParam, actualParametersList[i]);
    }
    return i - 1;
  }

  /**
   *
   * @param {import('./../../ast/commands/function').Function} fun
   * @param {import('./../../ast/commands/formalParameter').FormalParameter} formalParam
   * @param {Expression} actualParameter
   */
  assertParameter (fun, formalParam, actualParameter) {
    // const id = formalParam.id;
    if (formalParam.byRef) {
      if (actualParameter instanceof VariableLiteral) {
        const variable = this.findSymbol(actualParameter.id, this.symbolMap);
        if (variable.isConst) {
          throw ProcessorErrorFactory.invalid_const_ref_full(
            fun.name,
            actualParameter.toString(),
            actualParameter.sourceInfo
          );
        }
      } else if (
        !(
          actualParameter instanceof VariableLiteral ||
          actualParameter instanceof ArrayAccess
        )
      ) {
        throw ProcessorErrorFactory.invalid_parameter_type_full(
          fun.name,
          actualParameter.toString(),
          actualParameter.sourceInfo
        );
      }
    }
    const resultType = this.evaluateExpressionType(actualParameter);
    if (
      resultType instanceof MultiType &&
      formalParam.type instanceof MultiType
    ) {
      let shared = 0;
      for (let j = 0; j < resultType.types.length; ++j) {
        const element = resultType.types[j];
        if (formalParam.type.types.indexOf(element) !== -1) {
          shared += 1;
        }
      }
      if (shared <= 0) {
        if (Config.enable_type_casting && !formalParam.byRef) {
          if (
            (!resultType.isCompatible(Types.INTEGER) &&
              !resultType.isCompatible(Types.REAL)) ||
            formalParam.type.isCompatible(Types.INTEGER) ||
            formalParam.type.isCompatible(Types.REAL)
          ) {
            throw ProcessorErrorFactory.invalid_parameter_type_full(
              fun.name,
              actualParameter.toString(),
              actualParameter.sourceInfo
            );
          }
        }
      }
    } else if (resultType instanceof MultiType) {
      if (!resultType.isCompatible(formalParam.type)) {
        if (Config.enable_type_casting && !formalParam.byRef) {
          if (
            (!resultType.isCompatible(Types.INTEGER) &&
              !resultType.isCompatible(Types.REAL)) ||
            formalParam.type.isCompatible(Types.INTEGER) ||
            formalParam.type.isCompatible(Types.REAL)
          ) {
            throw ProcessorErrorFactory.invalid_parameter_type_full(
              fun.name,
              actualParameter.toString(),
              actualParameter.sourceInfo
            );
          }
        }
      }
    } else if (!formalParam.type.isCompatible(resultType)) {
      if (Config.enable_type_casting && !formalParam.byRef) {
        if (!Store.canImplicitTypeCast(formalParam.type, resultType)) {
          throw ProcessorErrorFactory.invalid_parameter_type_full(
            fun.name,
            actualParameter.toString(),
            actualParameter.sourceInfo
          );
        }
      }
    }
  }
}