src/com/google/clearsilver/jsilver/compiler/ExpressionTranslator.java

/*
 * Copyright (C) 2010 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.clearsilver.jsilver.compiler;

import com.google.clearsilver.jsilver.compiler.JavaExpression.Type;
import static com.google.clearsilver.jsilver.compiler.JavaExpression.bool;
import static com.google.clearsilver.jsilver.compiler.JavaExpression.call;
import static com.google.clearsilver.jsilver.compiler.JavaExpression.callFindVariable;
import static com.google.clearsilver.jsilver.compiler.JavaExpression.callOn;
import static com.google.clearsilver.jsilver.compiler.JavaExpression.declare;
import static com.google.clearsilver.jsilver.compiler.JavaExpression.integer;
import static com.google.clearsilver.jsilver.compiler.JavaExpression.string;
import com.google.clearsilver.jsilver.syntax.analysis.DepthFirstAdapter;
import com.google.clearsilver.jsilver.syntax.node.AAddExpression;
import com.google.clearsilver.jsilver.syntax.node.AAndExpression;
import com.google.clearsilver.jsilver.syntax.node.ADecimalExpression;
import com.google.clearsilver.jsilver.syntax.node.ADescendVariable;
import com.google.clearsilver.jsilver.syntax.node.ADivideExpression;
import com.google.clearsilver.jsilver.syntax.node.AEqExpression;
import com.google.clearsilver.jsilver.syntax.node.AExistsExpression;
import com.google.clearsilver.jsilver.syntax.node.AFunctionExpression;
import com.google.clearsilver.jsilver.syntax.node.AGtExpression;
import com.google.clearsilver.jsilver.syntax.node.AGteExpression;
import com.google.clearsilver.jsilver.syntax.node.AHexExpression;
import com.google.clearsilver.jsilver.syntax.node.ALtExpression;
import com.google.clearsilver.jsilver.syntax.node.ALteExpression;
import com.google.clearsilver.jsilver.syntax.node.AModuloExpression;
import com.google.clearsilver.jsilver.syntax.node.AMultiplyExpression;
import com.google.clearsilver.jsilver.syntax.node.ANameVariable;
import com.google.clearsilver.jsilver.syntax.node.ANeExpression;
import com.google.clearsilver.jsilver.syntax.node.ANegativeExpression;
import com.google.clearsilver.jsilver.syntax.node.ANotExpression;
import com.google.clearsilver.jsilver.syntax.node.ANumericAddExpression;
import com.google.clearsilver.jsilver.syntax.node.ANumericEqExpression;
import com.google.clearsilver.jsilver.syntax.node.ANumericExpression;
import com.google.clearsilver.jsilver.syntax.node.ANumericNeExpression;
import com.google.clearsilver.jsilver.syntax.node.AOrExpression;
import com.google.clearsilver.jsilver.syntax.node.AStringExpression;
import com.google.clearsilver.jsilver.syntax.node.ASubtractExpression;
import com.google.clearsilver.jsilver.syntax.node.AVariableExpression;
import com.google.clearsilver.jsilver.syntax.node.PExpression;

import java.util.LinkedList;

/**
 * Translates a CS expression (from the AST) into an equivalent Java expression.
 * 
 * In order to optimize the expressions nicely this class emits code using a series of wrapper
 * functions for casting to/from various types. Rather than the old style of saying:
 * 
 * <pre>ValueX.asFoo()</pre>
 * 
 * we now write:
 * 
 * <pre>asFoo(ValueX)</pre>
 * 
 * This is actually very important because it means that as we optimize the expressions to return
 * fundamental types, we just have different versions of the {@code asFoo()} methods that take the
 * appropriate types. The user of the expression is responsible for casting it and the producer of
 * the expression is now free to produce optimized expressions.
 */
public class ExpressionTranslator extends DepthFirstAdapter {

  private JavaExpression currentJavaExpression;

  /**
   * Translate a template AST expression into a Java String expression.
   */
  public JavaExpression translateToString(PExpression csExpression) {
    return translateUntyped(csExpression).cast(Type.STRING);
  }

  /**
   * Translate a template AST expression into a Java boolean expression.
   */
  public JavaExpression translateToBoolean(PExpression csExpression) {
    return translateUntyped(csExpression).cast(Type.BOOLEAN);
  }

  /**
   * Translate a template AST expression into a Java integer expression.
   */
  public JavaExpression translateToNumber(PExpression csExpression) {
    return translateUntyped(csExpression).cast(Type.INT);
  }

  /**
   * Translate a template AST expression into a Java Data expression.
   */
  public JavaExpression translateToData(PExpression csExpression) {
    return translateUntyped(csExpression).cast(Type.DATA);
  }

  /**
   * Translate a template AST expression into a Java Data expression.
   */
  public JavaExpression translateToVarName(PExpression csExpression) {
    return translateUntyped(csExpression).cast(Type.VAR_NAME);
  }

  /**
   * Translate a template AST expression into a Java Value expression.
   */
  public JavaExpression translateToValue(PExpression csExpression) {
    return translateUntyped(csExpression).cast(Type.VALUE);
  }

  /**
   * Declares the (typed) expression as a variable with the given name. (e.g. "int foo = 5" or
   * "Data foo = Data.getChild("a.b")"
   */
  public JavaExpression declareAsVariable(String name, PExpression csExpression) {
    JavaExpression expression = translateUntyped(csExpression);
    Type type = expression.getType();
    assert type != null : "all subexpressions should be typed";
    return declare(type, name, expression);
  }

  /**
   * Translate a template AST expression into an untyped expression.
   */
  public JavaExpression translateUntyped(PExpression csExpression) {
    try {
      assert currentJavaExpression == null : "Not reentrant";
      csExpression.apply(this);
      assert currentJavaExpression != null : "No expression created";
      return currentJavaExpression;
    } finally {
      currentJavaExpression = null;
    }
  }

  private void setResult(JavaExpression javaExpression) {
    this.currentJavaExpression = javaExpression;
  }

  /**
   * Process AST node for a variable (e.g. a.b.c).
   */
  @Override
  public void caseAVariableExpression(AVariableExpression node) {
    JavaExpression varName = new VariableTranslator(this).translate(node.getVariable());
    setResult(varName);
  }

  /**
   * Process AST node for a string (e.g. "hello").
   */
  @Override
  public void caseAStringExpression(AStringExpression node) {
    String value = node.getValue().getText();
    value = value.substring(1, value.length() - 1); // Remove enclosing quotes.
    setResult(string(value));
  }

  /**
   * Process AST node for a decimal integer (e.g. 123).
   */
  @Override
  public void caseADecimalExpression(ADecimalExpression node) {
    String value = node.getValue().getText();
    setResult(integer(value));
  }

  /**
   * Process AST node for a hex integer (e.g. 0x1AB).
   */
  @Override
  public void caseAHexExpression(AHexExpression node) {
    String value = node.getValue().getText();
    // Luckily ClearSilver hex representation is a subset of the Java hex
    // representation so we can just use the literal directly.
    // TODO: add well-formedness checks whenever literals are used
    setResult(integer(value));
  }

  /*
   * The next block of functions all convert CS operators into dynamically looked up functions.
   */

  @Override
  public void caseANumericExpression(ANumericExpression node) {
    setResult(cast(Type.INT, node.getExpression()));
  }

  @Override
  public void caseANotExpression(ANotExpression node) {
    setResult(prefix(Type.BOOLEAN, Type.BOOLEAN, "!", node.getExpression()));
  }

  @Override
  public void caseAExistsExpression(AExistsExpression node) {
    // Special case. Exists is only ever an issue for variables, all
    // other expressions unconditionally exist.
    PExpression expression = node.getExpression();
    if (expression instanceof AVariableExpression) {
      expression.apply(this);
      if (currentJavaExpression.getType() == Type.VAR_NAME) {
        currentJavaExpression = callFindVariable(currentJavaExpression, false);
      }
      setResult(call(Type.BOOLEAN, "exists", currentJavaExpression));
    } else {
      // If it's not a variable, it always exists
      // NOTE: It's not clear if we must evaluate the sub-expression
      // here (is there anything that can have side effects??)
      setResult(bool(true));
    }
  }

  @Override
  public void caseAEqExpression(AEqExpression node) {
    JavaExpression left = cast(Type.STRING, node.getLeft());
    JavaExpression right = cast(Type.STRING, node.getRight());
    setResult(callOn(Type.BOOLEAN, left, "equals", right));
  }

  @Override
  public void caseANumericEqExpression(ANumericEqExpression node) {
    setResult(infix(Type.BOOLEAN, Type.INT, "==", node.getLeft(), node.getRight()));
  }

  @Override
  public void caseANeExpression(ANeExpression node) {
    JavaExpression left = cast(Type.STRING, node.getLeft());
    JavaExpression right = cast(Type.STRING, node.getRight());
    setResult(JavaExpression.prefix(Type.BOOLEAN, "!", callOn(Type.BOOLEAN, left, "equals", right)));
  }

  @Override
  public void caseANumericNeExpression(ANumericNeExpression node) {
    setResult(infix(Type.BOOLEAN, Type.INT, "!=", node.getLeft(), node.getRight()));
  }

  @Override
  public void caseALtExpression(ALtExpression node) {
    setResult(infix(Type.BOOLEAN, Type.INT, "<", node.getLeft(), node.getRight()));
  }

  @Override
  public void caseAGtExpression(AGtExpression node) {
    setResult(infix(Type.BOOLEAN, Type.INT, ">", node.getLeft(), node.getRight()));
  }

  @Override
  public void caseALteExpression(ALteExpression node) {
    setResult(infix(Type.BOOLEAN, Type.INT, "<=", node.getLeft(), node.getRight()));
  }

  @Override
  public void caseAGteExpression(AGteExpression node) {
    setResult(infix(Type.BOOLEAN, Type.INT, ">=", node.getLeft(), node.getRight()));
  }

  @Override
  public void caseAAndExpression(AAndExpression node) {
    setResult(infix(Type.BOOLEAN, Type.BOOLEAN, "&&", node.getLeft(), node.getRight()));
  }

  @Override
  public void caseAOrExpression(AOrExpression node) {
    setResult(infix(Type.BOOLEAN, Type.BOOLEAN, "||", node.getLeft(), node.getRight()));
  }

  @Override
  public void caseAAddExpression(AAddExpression node) {
    setResult(infix(Type.STRING, Type.STRING, "+", node.getLeft(), node.getRight()));
  }

  @Override
  public void caseANumericAddExpression(ANumericAddExpression node) {
    setResult(infix(Type.INT, Type.INT, "+", node.getLeft(), node.getRight()));
  }

  @Override
  public void caseASubtractExpression(ASubtractExpression node) {
    setResult(infix(Type.INT, Type.INT, "-", node.getLeft(), node.getRight()));
  }

  @Override
  public void caseAMultiplyExpression(AMultiplyExpression node) {
    setResult(infix(Type.INT, Type.INT, "*", node.getLeft(), node.getRight()));
  }

  @Override
  public void caseADivideExpression(ADivideExpression node) {
    setResult(infix(Type.INT, Type.INT, "/", node.getLeft(), node.getRight()));
  }

  @Override
  public void caseAModuloExpression(AModuloExpression node) {
    setResult(infix(Type.INT, Type.INT, "%", node.getLeft(), node.getRight()));
  }

  @Override
  public void caseANegativeExpression(ANegativeExpression node) {
    setResult(prefix(Type.INT, Type.INT, "-", node.getExpression()));
  }

  /**
   * Process AST node for a function (e.g. dosomething(...)).
   */
  @Override
  public void caseAFunctionExpression(AFunctionExpression node) {
    LinkedList<PExpression> argsList = node.getArgs();
    PExpression[] args = argsList.toArray(new PExpression[argsList.size()]);

    // Because the function name may have dots in, the parser would have broken
    // it into a little node tree which we need to walk to reconstruct the
    // full name.
    final StringBuilder fullFunctionName = new StringBuilder();
    node.getName().apply(new DepthFirstAdapter() {

      @Override
      public void caseANameVariable(ANameVariable node11) {
        fullFunctionName.append(node11.getWord().getText());
      }

      @Override
      public void caseADescendVariable(ADescendVariable node12) {
        node12.getParent().apply(this);
        fullFunctionName.append('.');
        node12.getChild().apply(this);
      }
    });

    setResult(function(fullFunctionName.toString(), args));
  }

  /**
   * Generate a JavaExpression for calling a function.
   */
  private JavaExpression function(String name, PExpression... csExpressions) {
    // Outputs: context.executeFunction("myfunc", args...);
    JavaExpression[] args = new JavaExpression[1 + csExpressions.length];
    args[0] = string(name);
    for (int i = 0; i < csExpressions.length; i++) {
      args[i + 1] = cast(Type.VALUE, csExpressions[i]);
    }
    return callOn(Type.VALUE, TemplateTranslator.CONTEXT, "executeFunction", args);
  }

  private JavaExpression infix(Type destType, Type srcType, String infix, PExpression leftNode,
      PExpression rightNode) {
    JavaExpression left = cast(srcType, leftNode);
    JavaExpression right = cast(srcType, rightNode);
    return JavaExpression.infix(destType, infix, left, right);
  }

  private JavaExpression prefix(Type destType, Type srcType, String prefix, PExpression node) {
    return JavaExpression.prefix(destType, prefix, cast(srcType, node));
  }

  private JavaExpression cast(Type type, PExpression node) {
    node.apply(this);
    return currentJavaExpression.cast(type);
  }
}