replaceInLiterals static method

Implementation

static Expression? replaceInLiterals(dynamic expression, Map<String, dynamic> variables)
{

  Type? expressionType;

       if (expression is ConditionalExpression) {
         expressionType = ConditionalExpression;
       } else if (expression is BinaryExpression) {
    expressionType = BinaryExpression;
  } else if (expression is CallExpression) {
    expressionType = CallExpression;
  } else if (expression is Literal) {
    expressionType = Literal;
  } else if (expression is Variable) {
    expressionType = Variable;
  }

  switch(expressionType)
  {
    case ConditionalExpression:

      expression = ConditionalExpression(expression.test, replaceInLiterals(expression.consequent, variables), replaceInLiterals(expression.alternate, variables));
      break;

    case BinaryExpression:
      expression = BinaryExpression(expression.operator, replaceInLiterals(expression.left, variables), replaceInLiterals(expression.right, variables));
      break;

    case CallExpression:
      List? args = expression.arguments;
      for (int i = 0; i < expression.arguments.length; i++) {
        args![i] = replaceInLiterals(expression.arguments[i], variables);
      }
      expression = CallExpression(expression.callee, args as List<Expression?>?);
      break;

    case Variable:
      String? name = expression.identifier?.name;
      bool exists = variables.containsKey(name);
      if (!exists)
      {
        String? value = _toString(name);
        expression = Literal(value,value);
      }
      break;

    case Literal:
      if (expression.value is String)
      {
        String v = expression.value ?? "";
        variables.forEach((key, value) => v = v.replaceAll(key, _toString(value) ?? key));
        expression = Literal(v,v);
      }
      break;

    default:
      break;
  }
  return expression;
}