/*
* Copyright 2009 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.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.dev.resource.Resource;
import com.google.gwt.dev.util.Util;
import com.google.gwt.dev.util.Name.BinaryName;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.core.util.CodeSnippetParsingUtil;
import java.io.InputStream;
import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.WeakHashMap;
/**
* Methods to do direct parsing of Java source -- currently the only uses are
* for finding actual method parameter names on request.
*/
public class JavaSourceParser {
public static JClassType getTopmostType(JClassType type) {
while (type.getEnclosingType() != null) {
type = type.getEnclosingType();
}
return type;
}
/**
* Spits a binary name into a series of char arrays, corresponding to
* enclosing classes.
*
* <p>For example, {@code test.Foo$Bar} gets expanded to [[Foo],[Bar]].
* Note that the package is not included.
*
* @param binaryName class name in binary form (ie, test.Foo$Bar)
* @return list of char arrays of class names, from outer to inner
*/
// @VisibleForTesting
static List<char[]> getClassChain(String binaryName) {
ArrayList<char[]> result = new ArrayList<char[]>();
String className = BinaryName.getClassName(binaryName);
int idx;
while ((idx = className.indexOf('$')) >= 0) {
result.add(className.substring(0, idx).toCharArray());
className = className.substring(idx + 1);
}
result.add(className.toCharArray());
return result;
}
/**
* Find a matching method in a type.
*
* @param type JDT method
* @param jMethod TypeOracle method object to find
* @return method declaration or null if not found
*/
private static AbstractMethodDeclaration findMethod(TypeDeclaration type,
JAbstractMethod jMethod) {
List<AbstractMethodDeclaration> candidates = findNamedMethods(type,
jMethod.getName());
if (candidates.size() == 0) {
return null;
}
if (candidates.size() == 1) {
return candidates.get(0);
}
nextCandidate: for (AbstractMethodDeclaration candidate : candidates) {
int n = candidate.arguments == null ? 0 : candidate.arguments.length;
JParameter[] params = jMethod.getParameters();
if (n != params.length) {
continue;
}
for (int i = 0; i < n; ++i) {
if (!typeMatches(candidate.arguments[i].type,
params[i].getType())) {
continue nextCandidate;
}
}
return candidate;
}
return null;
}
/**
* Find all methods which have the requested name.
*
* <p>{@code <clinit>} is not supported.
* @param type JDT type declaration
* @param name name of methods to find
* @return list of matching methods
*/
private static List<AbstractMethodDeclaration> findNamedMethods(
TypeDeclaration type, String name) {
List<AbstractMethodDeclaration> matching = new ArrayList<AbstractMethodDeclaration>();
boolean isCtor = "<init>".equals(name);
char[] nameArray = name.toCharArray();
for (AbstractMethodDeclaration method : type.methods) {
if ((isCtor && method.isConstructor()) ||
(!isCtor && !method.isConstructor() && !method.isClinit()
&& Arrays.equals(method.selector, nameArray))) {
matching.add(method);
}
}
return matching;
}
/**
* Find a particular type in a compilation unit.
*
* @param unit JDT cud
* @param binaryName binary name of the type to find (ie, test.Foo$Bar)
* @return type declaration or null if not found
*/
private static TypeDeclaration findType(CompilationUnitDeclaration unit,
String binaryName) {
List<char[]> classChain = getClassChain(binaryName);
TypeDeclaration curType = findType(unit.types, classChain.get(0));
for (int i = 1; i < classChain.size(); ++i) {
if (curType == null) {
return null;
}
curType = findType(curType.memberTypes, classChain.get(i));
}
return curType;
}
/**
* Find one type by name in a array of types.
*
* @param types array of types
* @param name name of type to find
* @return matching type or null if not found
*/
private static TypeDeclaration findType(TypeDeclaration[] types, char[] name) {
for (TypeDeclaration type : types) {
if (Arrays.equals(name, type.name)) {
return type;
}
}
return null;
}
/**
* Parse Java source.
*
* @param javaSource String containing Java source to parse
* @return a CompilationUnitDeclaration or null if parsing failed
*/
private static CompilationUnitDeclaration parseJava(String javaSource) {
CodeSnippetParsingUtil parsingUtil = new CodeSnippetParsingUtil();
CompilerOptions options = new CompilerOptions();
options.complianceLevel = ClassFileConstants.JDK1_5;
options.sourceLevel = ClassFileConstants.JDK1_5;
CompilationUnitDeclaration unit = parsingUtil.parseCompilationUnit(
javaSource.toString().toCharArray(), options.getMap(), true);
if (unit.compilationResult().hasProblems()) {
return null;
}
return unit;
}
/**
* Compares an unresolved JDT type to a TypeOracle type to see if they match.
*
* @param jdtType
* @param toType
* @return true if the two type objects resolve to the same
*/
private static boolean typeMatches(TypeReference jdtType, JType toType) {
List<char[]> toNameComponents = getClassChain(
toType.getQualifiedBinaryName());
int toLen = toNameComponents.size();
char[][] jdtNameComponents = jdtType.getTypeName();
int jdtLen = jdtNameComponents.length;
int maxToCompare = Math.min(toLen, jdtLen);
// compare from the end
for (int i = 1; i <= maxToCompare; ++i) {
if (!Arrays.equals(jdtNameComponents[jdtLen - i],
toNameComponents.get(toLen - i))) {
return false;
}
}
return true;
}
/**
* Map of top-level classes to the source file associated with it.
*/
private WeakHashMap<JClassType, Resource> classSources = new WeakHashMap<JClassType, Resource>();
/**
* Cache of top-level classes to JDT CUDs associated with them.
*
* <p>CUDs may be discarded at any time (with a performance cost if they are
* needed again), and are held in SoftReferences to allow GC to dump them.
*/
private WeakHashMap<JClassType, SoftReference<CompilationUnitDeclaration>> cudCache = new WeakHashMap<JClassType, SoftReference<CompilationUnitDeclaration>>();
/**
* Add a source file associated with the outermost enclosing class.
*
* @param topType
* @param source
*
* TODO: reduce visibility
*/
public synchronized void addSourceForType(JClassType topType, Resource source) {
classSources.put(topType, source);
}
/**
* Return the real argument names for a given method from the source.
*
* @param method method to lookup parameter names for
* @return array of argument names or null if no source is available
*/
public synchronized String[] getArguments(JAbstractMethod method) {
JClassType type = method.getEnclosingType();
JClassType topType = getTopmostType(type);
CompilationUnitDeclaration cud = getCudForTopLevelType(topType);
if (cud == null) {
return null;
}
TypeDeclaration jdtType = findType(cud, type.getQualifiedBinaryName());
if (jdtType == null) {
// TODO(jat): any thing else to do here?
return null;
}
AbstractMethodDeclaration jdtMethod = findMethod(jdtType, method);
if (jdtMethod == null) {
// TODO(jat): any thing else to do here?
return null;
}
int n = jdtMethod.arguments.length;
String[] argNames = new String[n];
for (int i = 0; i < n; ++i) {
argNames[i] = String.valueOf(jdtMethod.arguments[i].name);
}
return argNames;
}
/**
* Finds a JDT CUD for a given top-level type, generating it if needed.
*
* @param topType top-level JClassType
* @return CUD instance or null if no source found
*/
private synchronized CompilationUnitDeclaration getCudForTopLevelType(
JClassType topType) {
CompilationUnitDeclaration cud = null;
if (cudCache.containsKey(topType)) {
SoftReference<CompilationUnitDeclaration> cudRef = cudCache.get(topType);
if (cudRef != null) {
cud = cudRef.get();
}
}
if (cud == null) {
Resource classSource = classSources.get(topType);
String source = null;
if (classSource != null) {
InputStream stream = classSource.openContents();
source = Util.readStreamAsString(stream);
}
if (source == null) {
// cache negative result so we don't try again
cudCache.put(topType, null);
} else {
cud = parseJava(source);
cudCache.put(topType,
new SoftReference<CompilationUnitDeclaration>(cud));
}
}
return cud;
}
}