LocalVariable.java

/*
 * Copyright 2015 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.template.soy.jbcsrc;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;

import com.google.common.base.Optional;
import org.objectweb.asm.Label;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;

/**
 * A local variable representation.
 *
 * <p>This does nothing to enforce required constraints, e.g.:
 *
 * <ul>
 *   <li>This does not ensure that {@link #start()} and {@link #end()} are valid and exist in the
 *       method.
 *   <li>This does not ensure that the {@link #index} is otherwise unused and that only one variable
 *       is active at a time with the index.
 * </ul>
 *
 * <p>Note: This class does not attempt to make use of the convenience methods on generator adapter
 * such as {@link CodeBuilder#newLocal(Type)} or {@link CodeBuilder#loadArg(int)} that make it
 * easier to work with local variables (and calculating local variable indexes). Instead we push
 * this responsibility onto our caller. This is because CodeBuilder doesn't make it possible to
 * generate local variable debugging tables in this case (e.g. there is no way to map a method
 * parameter index to a local variable index).
 */
final class LocalVariable extends Expression {
  // TODO(lukes): the fact that you need to specify the start and end labels during construction
  // ends up being awkward... Due to the fact that it is unclear who is responsible for actually
  // visiting the labels.  Maybe this object should be label agnostic and the labels should just be
  // parameters to tableEntry?

  static LocalVariable createThisVar(TypeInfo owner, Label start, Label end) {
    return new LocalVariable("this", owner.type(), 0, start, end, Feature.NON_NULLABLE);
  }

  static LocalVariable createLocal(String name, int index, Type type, Label start, Label end) {
    checkArgument(!name.equals("this"));
    return new LocalVariable(name, type, index, start, end);
  }

  private final String variableName;
  private final int index;
  private final Label start;
  private final Label end;

  private LocalVariable(
      String variableName, Type type, int index, Label start, Label end, Feature... features) {
    super(type, Feature.CHEAP /* locals are always cheap */, features);
    this.variableName = checkNotNull(variableName);
    this.index = index;
    this.start = checkNotNull(start);
    this.end = checkNotNull(end);
  }

  /** The name of the variable, ends up in debugging tables. */
  String variableName() {
    return variableName;
  }

  int index() {
    return index;
  }

  /** A label defining the earliest point at which this variable is defined. */
  Label start() {
    return start;
  }

  /** A label defining the latest point at which this variable is defined. */
  Label end() {
    return end;
  }

  @Override
  LocalVariable asCheap() {
    return this;
  }

  @Override
  LocalVariable asNonNullable() {
    if (isNonNullable()) {
      return this;
    }
    return new LocalVariable(variableName, resultType(), index, start, end, Feature.NON_NULLABLE);
  }

  /**
   * Write a local variable table entry for this variable. This informs debuggers about variable
   * names, types and lifetime.
   */
  void tableEntry(CodeBuilder mv) {
    mv.visitLocalVariable(
        variableName(),
        resultType().getDescriptor(),
        null, // no generic signature
        start(),
        end(),
        index());
  }

  @Override
  void doGen(CodeBuilder mv) {
    mv.visitVarInsn(resultType().getOpcode(Opcodes.ILOAD), index());
  }

  /**
   * Return a {@link Statement} that stores the value of the given expression into this variable.
   */
  Statement store(final Expression expr) {
    return store(expr, Optional.<Label>absent());
  }

  /**
   * Return a {@link Statement} that stores the value of the given expression into this variable.
   *
   * @param expr The expression to store
   * @param firstVarInstruction A label to use to mark the store instruction
   */
  Statement store(final Expression expr, Label firstVarInstruction) {
    return store(expr, Optional.<Label>of(firstVarInstruction));
  }

  /** Writes the value at the top of the stack to the local variable. */
  private Statement store(final Expression expr, final Optional<Label> firstVarInstruction) {
    expr.checkAssignableTo(resultType());
    return new Statement() {
      @Override
      void doGen(CodeBuilder adapter) {
        expr.gen(adapter);
        if (firstVarInstruction.isPresent()) {
          adapter.mark(firstVarInstruction.get());
        }
        adapter.visitVarInsn(resultType().getOpcode(Opcodes.ISTORE), index());
      }
    };
  }
}