2.4/dev/core/src/com/google/gwt/dev/javac/MethodArgNamesLookup.java

/*
 * Copyright 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.gwt.dev.javac;

import com.google.gwt.core.ext.typeinfo.JAbstractMethod;
import com.google.gwt.dev.javac.asm.CollectMethodData;
import com.google.gwt.dev.util.StringInterner;
import com.google.gwt.dev.util.collect.Maps;

import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

/**
 * Keeps track of method argument names that cannot be read from just the
 * bytecode.
 */
public class MethodArgNamesLookup implements Serializable {

  private Map<String, String[]> methodArgs;

  public MethodArgNamesLookup() {
    this.methodArgs = new HashMap<String, String[]>();
  }

  /**
   * Prevent further modification to this object. Calls to
   * {@link #store(String, AbstractMethodDeclaration)} or
   * {@link #mergeFrom(MethodArgNamesLookup)} on this object will fail after
   * this method is called.
   */
  public void freeze() {
    methodArgs = Maps.normalizeUnmodifiable(methodArgs);
  }

  /**
   * Lookup the argument names for a given method.
   * 
   * @param method TypeOracle method
   * @param methodData method data collected from bytecode
   * @return an array of the argument names, or null if unavailable
   */
  public String[] lookup(JAbstractMethod method, CollectMethodData methodData) {
    StringBuilder buf = new StringBuilder();
    buf.append(method.getEnclosingType().getQualifiedBinaryName());
    buf.append('.').append(method.getName());
    buf.append(methodData.getDesc());
    String key = buf.toString();
    return methodArgs.get(key);
  }

  /**
   * Merge argument names from another lookup map into this one.
   * 
   * @param other
   */
  public void mergeFrom(MethodArgNamesLookup other) {
    methodArgs.putAll(other.methodArgs);
  }

  /**
   * Store the argument names for a method.
   * <p>
   * <b>Note: method must have non-zero arguments.<b>
   * 
   * @param enclosingType fully qualified binary name of the enclosing type
   * @param method JDT method
   */
  public void store(String enclosingType, AbstractMethodDeclaration method) {
    if (method.binding == null) {
      // Compile problem with this method, skip
      return;
    }
    int n = method.arguments.length;
    String[] argNames = new String[n];
    for (int i = 0; i < n; ++i) {
      argNames[i] = StringInterner.get().intern(
          String.valueOf(method.arguments[i].name));
    }
    StringBuilder buf = new StringBuilder();
    buf.append(enclosingType).append('.').append(method.selector);
    buf.append(method.binding.signature());
    String key = StringInterner.get().intern(buf.toString());
    methodArgs.put(key, argNames);
  }

  /**
   * For Unit Testing: returns an array of methods with arguments.
   */
  String[] getMethods() {
    return methodArgs.keySet().toArray(new String[0]);
  }

  /**
   * For Unit Testing: returns an array of argument names for the specified
   * method.
   */
  String[] lookup(String methodName) {
    return methodArgs.get(methodName);
  }
}