| package annotator.find; |
| |
| import annotator.Main; |
| |
| import java.util.ArrayList; |
| import java.util.EnumSet; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import plume.UtilMDE; |
| |
| import com.sun.source.tree.AnnotatedTypeTree; |
| import com.sun.source.tree.ClassTree; |
| import com.sun.source.tree.CompilationUnitTree; |
| import com.sun.source.tree.ExpressionTree; |
| import com.sun.source.tree.ImportTree; |
| import com.sun.source.tree.MethodTree; |
| import com.sun.source.tree.Tree; |
| import com.sun.source.tree.TypeParameterTree; |
| import com.sun.source.tree.VariableTree; |
| import com.sun.source.util.TreePath; |
| |
| public class IsSigMethodCriterion implements Criterion { |
| |
| // The context is used for determining the fully qualified name of methods. |
| private static class Context { |
| public final String packageName; |
| public final List<String> imports; |
| public Context(String packageName, List<String> imports) { |
| this.packageName = packageName; |
| this.imports = imports; |
| } |
| } |
| |
| private static final Map<CompilationUnitTree, Context> contextCache = new HashMap<CompilationUnitTree, Context>(); |
| |
| private final String fullMethodName; // really the full JVML signature, sans return type |
| private final String simpleMethodName; |
| // list of parameters in Java, not JVML format |
| private final List<String> fullyQualifiedParams; |
| // in Java, not JVML, format. may be "void" |
| private final String returnType; |
| |
| public IsSigMethodCriterion(String methodName) { |
| this.fullMethodName = methodName.substring(0, methodName.indexOf(")") + 1); |
| this.simpleMethodName = methodName.substring(0, methodName.indexOf("(")); |
| // this.fullyQualifiedParams = new ArrayList<String>(); |
| // for (String s : methodName.substring( |
| // methodName.indexOf("(") + 1, methodName.indexOf(")")).split(",")) { |
| // if (s.length() > 0) { |
| // fullyQualifiedParams.add(s); |
| // } |
| // } |
| this.fullyQualifiedParams = new ArrayList<String>(); |
| try { |
| parseParams( |
| methodName.substring(methodName.indexOf("(") + 1, |
| methodName.indexOf(")"))); |
| } catch (Exception e) { |
| throw new RuntimeException("Caught exception while parsing method: " + |
| methodName, e); |
| } |
| String returnTypeJvml = methodName.substring(methodName.indexOf(")") + 1); |
| this.returnType = (returnTypeJvml.equals("V") |
| ? "void" |
| : UtilMDE.fieldDescriptorToBinaryName(returnTypeJvml)); |
| } |
| |
| // params is in JVML format |
| private void parseParams(String params) { |
| while (params.length() != 0) { |
| // nextParam is in JVML format |
| String nextParam = readNext(params); |
| params = params.substring(nextParam.length()); |
| fullyQualifiedParams.add(UtilMDE.fieldDescriptorToBinaryName(nextParam)); |
| } |
| } |
| |
| // strip a JVML type off a string containing multiple concatenated JVML types |
| private String readNext(String restOfParams) { |
| String firstChar = restOfParams.substring(0, 1); |
| if (isPrimitiveLetter(firstChar)) { |
| return firstChar; |
| } else if (firstChar.equals("[")) { |
| return "[" + readNext(restOfParams.substring(1)); |
| } else if (firstChar.equals("L")) { |
| return "L" + restOfParams.substring(1, restOfParams.indexOf(";") + 1); |
| } else { |
| throw new RuntimeException("Unknown method params: " + fullMethodName + " with remainder: " + restOfParams); |
| } |
| } |
| |
| // called by isSatisfiedBy(TreePath), will get compilation unit on its own |
| private static Context initImports(TreePath path) { |
| CompilationUnitTree topLevel = path.getCompilationUnit(); |
| Context result = contextCache.get(topLevel); |
| if (result != null) { |
| return result; |
| } |
| |
| ExpressionTree packageTree = topLevel.getPackageName(); |
| String packageName; |
| if (packageTree == null) { |
| packageName = ""; // the default package |
| } else { |
| packageName = packageTree.toString(); |
| } |
| |
| List<String> imports = new ArrayList<String>(); |
| for (ImportTree i : topLevel.getImports()) { |
| String imported = i.getQualifiedIdentifier().toString(); |
| imports.add(imported); |
| } |
| |
| result = new Context(packageName, imports); |
| contextCache.put(topLevel, result); |
| return result; |
| } |
| |
| // Abstracts out the inner loop of matchTypeParams. |
| // goalType is fully-qualified. |
| private boolean matchTypeParam(String goalType, Tree type, |
| Map<String, String> typeToClassMap, |
| Context context) { |
| String simpleType = type.toString(); |
| |
| boolean haveMatch = matchSimpleType(goalType, simpleType, context); |
| if (!haveMatch) { |
| if (!typeToClassMap.isEmpty()) { |
| for (Map.Entry<String, String> p : typeToClassMap.entrySet()) { |
| simpleType = simpleType.replaceAll("\\b" + p.getKey() + "\\b", |
| p.getValue()); |
| haveMatch = matchSimpleType(goalType, simpleType, context); |
| if (!haveMatch) { |
| Criteria.dbug.debug("matchTypeParams() => false:%n"); |
| Criteria.dbug.debug(" type = %s%n", type); |
| Criteria.dbug.debug(" simpleType = %s%n", simpleType); |
| Criteria.dbug.debug(" goalType = %s%n", goalType); |
| } |
| } |
| } |
| } |
| return haveMatch; |
| } |
| |
| |
| private boolean matchTypeParams(List<? extends VariableTree> sourceParams, |
| Map<String, String> typeToClassMap, |
| Context context) { |
| assert sourceParams.size() == fullyQualifiedParams.size(); |
| for (int i = 0; i < sourceParams.size(); i++) { |
| String fullType = fullyQualifiedParams.get(i); |
| VariableTree vt = sourceParams.get(i); |
| Tree vtType = vt.getType(); |
| if (! matchTypeParam(fullType, vtType, typeToClassMap, context)) { |
| Criteria.dbug.debug( |
| "matchTypeParam() => false:%n i=%d vt = %s%n fullType = %s%n", |
| i, vt, fullType); |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| |
| // simpleType is the name as it appeared in the source code. |
| // fullType is fully-qualified. |
| // Both are in Java, not JVML, format. |
| private boolean matchSimpleType(String fullType, String simpleType, Context context) { |
| Criteria.dbug.debug("matchSimpleType(%s, %s, %s)%n", |
| fullType, simpleType, context); |
| |
| // must strip off generics, is all of this necessary, though? |
| // do you ever have generics anywhere but at the end? |
| while (simpleType.contains("<")) { |
| int bracketIndex = simpleType.lastIndexOf("<"); |
| String beforeBracket = simpleType.substring(0, bracketIndex); |
| String afterBracket = simpleType.substring(simpleType.indexOf(">", bracketIndex) + 1); |
| simpleType = beforeBracket + afterBracket; |
| } |
| |
| |
| // TODO: arrays? |
| |
| // first try qualifying simpleType with this package name, |
| // then with java.lang |
| // then with default package |
| // then with all of the imports |
| |
| boolean matchable = false; |
| |
| if (!matchable) { |
| // match with this package name |
| String packagePrefix = context.packageName; |
| if (packagePrefix.length() > 0) { |
| packagePrefix = packagePrefix + "."; |
| } |
| if (matchWithPrefix(fullType, simpleType, packagePrefix)) { |
| matchable = true; |
| } |
| } |
| |
| if (!matchable) { |
| // match with java.lang |
| if (matchWithPrefix(fullType, simpleType, "java.lang.")) { |
| matchable = true; |
| } |
| } |
| |
| if (!matchable) { |
| // match with default package |
| if (matchWithPrefix(fullType, simpleType, "")) { |
| matchable = true; |
| } |
| } |
| |
| /* |
| * From Java 7 language definition 6.5.5.2 (Qualified Types): |
| * If a type name is of the form Q.Id, then Q must be either a type |
| * name or a package name. If Id names exactly one accessible type |
| * that is a member of the type or package denoted by Q, then the |
| * qualified type name denotes that type. |
| */ |
| if (!matchable) { |
| // match with any of the imports |
| for (String someImport : context.imports) { |
| String importPrefix = null; |
| if (someImport.contains("*")) { |
| // don't include the * in the prefix, should end in . |
| // TODO: this is a real bug due to nonnull, though I discovered it manually |
| // importPrefix = someImport.substring(0, importPrefix.indexOf("*")); |
| importPrefix = someImport.substring(0, someImport.indexOf("*")); |
| } else { |
| // if you imported a specific class, you can only use that import |
| // if the last part matches the simple type |
| String importSimpleType = |
| someImport.substring(someImport.lastIndexOf(".") + 1); |
| |
| // Remove array brackets from simpleType if it has them |
| int arrayBracket = simpleType.indexOf('['); |
| String simpleBaseType = simpleType; |
| if (arrayBracket > -1) { |
| simpleBaseType = simpleType.substring(0, arrayBracket); |
| } |
| if (!(simpleBaseType.equals(importSimpleType) |
| || simpleBaseType.startsWith(importSimpleType + "."))) { |
| continue; |
| } |
| |
| importPrefix = someImport.substring(0, someImport.lastIndexOf(".") + 1); |
| } |
| |
| if (matchWithPrefix(fullType, simpleType, importPrefix)) { |
| matchable = true; |
| break; // out of for loop |
| } |
| } |
| } |
| |
| return matchable; |
| } |
| |
| private boolean matchWithPrefix(String fullType, String simpleType, String prefix) { |
| return matchWithPrefixOneWay(fullType, simpleType, prefix) |
| || matchWithPrefixOneWay(simpleType, fullType, prefix); |
| } |
| |
| // simpleType can be in JVML format ?? Is that really possible? |
| private boolean matchWithPrefixOneWay(String fullType, String simpleType, |
| String prefix) { |
| |
| // maybe simpleType is in JVML format |
| String simpleType2 = simpleType.replace("/", "."); |
| |
| String fullType2 = fullType.replace("$", "."); |
| |
| /* unused String prefix2 = (prefix.endsWith(".") |
| ? prefix.substring(0, prefix.length() - 1) |
| : prefix); */ |
| boolean b = (fullType2.equals(prefix + simpleType2) |
| // Hacky way to handle the possibility that fulltype is an |
| // inner type but simple type is unqualified. |
| || (fullType.startsWith(prefix) |
| && (fullType.endsWith("$" + simpleType2) |
| || fullType2.endsWith("." + simpleType2)))); |
| Criteria.dbug.debug("matchWithPrefix(%s, %s, %s) => %b)%n", |
| fullType2, simpleType, prefix, b); |
| return b; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public boolean isSatisfiedBy(TreePath path, Tree leaf) { |
| assert path == null || path.getLeaf() == leaf; |
| return isSatisfiedBy(path); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public boolean isSatisfiedBy(TreePath path) { |
| if (path == null) { |
| return false; |
| } |
| |
| Context context = initImports(path); |
| |
| Tree leaf = path.getLeaf(); |
| |
| if (leaf.getKind() != Tree.Kind.METHOD) { |
| Criteria.dbug.debug( |
| "IsSigMethodCriterion.isSatisfiedBy(%s) => false: not a METHOD tree%n", |
| Main.pathToString(path)); |
| return false; |
| } |
| // else if ((((JCMethodDecl) leaf).mods.flags & Flags.GENERATEDCONSTR) != 0) { |
| // Criteria.dbug.debug( |
| // "IsSigMethodCriterion.isSatisfiedBy(%s) => false: generated constructor%n", |
| // Main.pathToString(path)); |
| // return false; |
| // } |
| |
| MethodTree mt = (MethodTree) leaf; |
| |
| if (! simpleMethodName.equals(mt.getName().toString())) { |
| Criteria.dbug.debug("IsSigMethodCriterion.isSatisfiedBy => false: Names don't match%n"); |
| return false; |
| } |
| |
| List<? extends VariableTree> sourceParams = mt.getParameters(); |
| if (fullyQualifiedParams.size() != sourceParams.size()) { |
| Criteria.dbug.debug("IsSigMethodCriterion.isSatisfiedBy => false: Number of parameters don't match%n"); |
| return false; |
| } |
| |
| // now go through all type parameters declared by method |
| // and for each one, create a mapping from the type to the |
| // first declared extended class, defaulting to Object |
| // for example, |
| // <T extends Date> void foo(T t) |
| // creates mapping: T -> Date |
| // <T extends Date & List> void foo(Object o) |
| // creates mapping: T -> Date |
| // <T extends Date, U extends List> foo(Object o) |
| // creates mappings: T -> Date, U -> List |
| // <T> void foo(T t) |
| // creates mapping: T -> Object |
| |
| Map<String, String> typeToClassMap = new HashMap<String, String>(); |
| for (TypeParameterTree param : mt.getTypeParameters()) { |
| String paramName = param.getName().toString(); |
| String paramClass = "Object"; |
| List<? extends Tree> paramBounds = param.getBounds(); |
| if (paramBounds != null && paramBounds.size() >= 1) { |
| Tree boundZero = paramBounds.get(0); |
| if (boundZero.getKind() == Tree.Kind.ANNOTATED_TYPE) { |
| boundZero = ((AnnotatedTypeTree) boundZero).getUnderlyingType(); |
| } |
| paramClass = boundZero.toString(); |
| } |
| typeToClassMap.put(paramName, paramClass); |
| } |
| |
| // Do the same for the enclosing class. |
| // The type variable might not be from the directly enclosing |
| // class, but from a further up class. |
| // Go through all enclosing classes and add the type parameters. |
| { |
| TreePath classpath = path; |
| ClassTree ct = enclosingClass(classpath); |
| while (ct!=null) { |
| for (TypeParameterTree param : ct.getTypeParameters()) { |
| String paramName = param.getName().toString(); |
| String paramClass = "Object"; |
| List<? extends Tree> paramBounds = param.getBounds(); |
| if (paramBounds != null && paramBounds.size() >= 1) { |
| Tree pb = paramBounds.get(0); |
| if (pb.getKind() == Tree.Kind.ANNOTATED_TYPE) { |
| pb = ((AnnotatedTypeTree)pb).getUnderlyingType(); |
| } |
| paramClass = pb.toString(); |
| } |
| typeToClassMap.put(paramName, paramClass); |
| } |
| classpath = classpath.getParentPath(); |
| ct = enclosingClass(classpath); |
| } |
| } |
| |
| if (! matchTypeParams(sourceParams, typeToClassMap, context)) { |
| Criteria.dbug.debug("IsSigMethodCriterion => false: Parameter types don't match%n"); |
| return false; |
| } |
| |
| if ((mt.getReturnType() != null) // must be a constructor |
| && (! matchTypeParam(returnType, mt.getReturnType(), typeToClassMap, context))) { |
| Criteria.dbug.debug("IsSigMethodCriterion => false: Return types don't match%n"); |
| return false; |
| } |
| |
| Criteria.dbug.debug("IsSigMethodCriterion.isSatisfiedBy => true%n"); |
| return true; |
| } |
| |
| /* This is a copy of the method from the Checker Framework |
| * TreeUtils.enclosingClass. |
| * We cannot have a dependency on the Checker Framework. |
| * TODO: as is the case there, anonymous classes are not handled correctly. |
| */ |
| private static ClassTree enclosingClass(final TreePath path) { |
| final Set<Tree.Kind> kinds = EnumSet.of( |
| Tree.Kind.CLASS, |
| Tree.Kind.ENUM, |
| Tree.Kind.INTERFACE, |
| Tree.Kind.ANNOTATION_TYPE |
| ); |
| TreePath p = path; |
| |
| while (p != null) { |
| Tree leaf = p.getLeaf(); |
| assert leaf != null; /*nninvariant*/ |
| if (kinds.contains(leaf.getKind())) { |
| return (ClassTree) leaf; |
| } |
| p = p.getParentPath(); |
| } |
| |
| return null; |
| } |
| |
| @Override |
| public Kind getKind() { |
| return Kind.SIG_METHOD; |
| } |
| |
| // public static String getSignature(MethodTree mt) { |
| // String sig = mt.getName().toString().trim(); // method name, no parameters |
| // sig += "("; |
| // boolean first = true; |
| // for (VariableTree vt : mt.getParameters()) { |
| // if (!first) { |
| // sig += ","; |
| // } |
| // sig += getType(vt.getType()); |
| // first = false; |
| // } |
| // sig += ")"; |
| // |
| // return sig; |
| // } |
| // |
| // private static String getType(Tree t) { |
| // if (t.getKind() == Tree.Kind.PRIMITIVE_TYPE) { |
| // return getPrimitiveType((PrimitiveTypeTree) t); |
| // } else if (t.getKind() == Tree.Kind.IDENTIFIER) { |
| // return "L" + ((IdentifierTree) t).getName().toString(); |
| // } else if (t.getKind() == Tree.Kind.PARAMETERIZED_TYPE) { |
| // // don't care about generics due to erasure |
| // return getType(((ParameterizedTypeTree) t).getType()); |
| // } |
| // throw new RuntimeException("unable to get type of: " + t); |
| // } |
| // |
| // private static String getPrimitiveType(PrimitiveTypeTree pt) { |
| // TypeKind tk = pt.getPrimitiveTypeKind(); |
| // if (tk == TypeKind.ARRAY) { |
| // return "["; |
| // } else if (tk == TypeKind.BOOLEAN) { |
| // return "Z"; |
| // } else if (tk == TypeKind.BYTE) { |
| // return "B"; |
| // } else if (tk == TypeKind.CHAR) { |
| // return "C"; |
| // } else if (tk == TypeKind.DOUBLE) { |
| // return "D"; |
| // } else if (tk == TypeKind.FLOAT) { |
| // return "F"; |
| // } else if (tk == TypeKind.INT) { |
| // return "I"; |
| // } else if (tk == TypeKind.LONG) { |
| // return "J"; |
| // } else if (tk == TypeKind.SHORT) { |
| // return "S"; |
| // } |
| // |
| // throw new RuntimeException("Invalid TypeKind: " + tk); |
| // } |
| |
| /* |
| private boolean isPrimitive(String s) { |
| return |
| s.equals("boolean") || |
| s.equals("byte") || |
| s.equals("char") || |
| s.equals("double") || |
| s.equals("float") || |
| s.equals("int") || |
| s.equals("long") || |
| s.equals("short"); |
| } |
| */ |
| |
| private boolean isPrimitiveLetter(String s) { |
| return |
| s.equals("Z") || |
| s.equals("B") || |
| s.equals("C") || |
| s.equals("D") || |
| s.equals("F") || |
| s.equals("I") || |
| s.equals("J") || |
| s.equals("S"); |
| } |
| |
| /* |
| private String primitiveLetter(String s) { |
| if (s.equals("boolean")) { |
| return "Z"; |
| } else if (s.equals("byte")) { |
| return "B"; |
| } else if (s.equals("char")) { |
| return "C"; |
| } else if (s.equals("double")) { |
| return "D"; |
| } else if (s.equals("float")) { |
| return "F"; |
| } else if (s.equals("int")) { |
| return "I"; |
| } else if (s.equals("long")) { |
| return "J"; |
| } else if (s.equals("short")) { |
| return "S"; |
| } else { |
| throw new RuntimeException("IsSigMethodCriterion: unknown primitive: " + s); |
| } |
| } |
| */ |
| |
| @Override |
| public String toString() { |
| return "IsSigMethodCriterion: " + fullMethodName; |
| } |
| } |
