/*
* Copyright (C) 2015 The Android Open Source Project
*
* 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.android.tools.lint;
import static com.android.SdkConstants.ATTR_NAME;
import static com.android.SdkConstants.DOT_JAR;
import static com.android.SdkConstants.FN_ANNOTATIONS_ZIP;
import static com.android.SdkConstants.VALUE_FALSE;
import static com.android.SdkConstants.VALUE_TRUE;
import static com.android.tools.lint.checks.SupportAnnotationDetector.PERMISSION_ANNOTATION;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.annotations.VisibleForTesting;
import com.android.builder.model.AndroidLibrary;
import com.android.builder.model.AndroidProject;
import com.android.builder.model.Dependencies;
import com.android.builder.model.Variant;
import com.android.tools.lint.client.api.JavaParser.DefaultTypeDescriptor;
import com.android.tools.lint.client.api.JavaParser.ResolvedAnnotation;
import com.android.tools.lint.client.api.JavaParser.ResolvedAnnotation.Value;
import com.android.tools.lint.client.api.JavaParser.ResolvedClass;
import com.android.tools.lint.client.api.JavaParser.ResolvedField;
import com.android.tools.lint.client.api.JavaParser.ResolvedMethod;
import com.android.tools.lint.client.api.JavaParser.ResolvedPackage;
import com.android.tools.lint.client.api.JavaParser.TypeDescriptor;
import com.android.tools.lint.client.api.LintClient;
import com.android.tools.lint.detector.api.LintUtils;
import com.android.tools.lint.detector.api.Project;
import com.android.utils.XmlUtils;
import com.google.common.base.Charsets;
import com.google.common.base.Splitter;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
import com.google.common.io.ByteStreams;
import com.google.common.io.Closeables;
import com.google.common.io.Files;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.jar.JarInputStream;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
/**
* Handler for IntelliJ database files for external annotations.
* It can be pointed to an annotations .jar file, which it then reads,
* and can return {@link ResolvedAnnotation} instances when queried
* for annotations on a {@link ResolvedClass} or a {@link ResolvedMethod},
* including its parameters.
*/
public class ExternalAnnotationRepository {
public static final String SDK_ANNOTATIONS_PATH = "platform-tools/api/annotations.zip"; //$NON-NLS-1$
public static final String FN_ANNOTATIONS_XML = "annotations.xml"; //$NON-NLS-1$
private static final boolean DEBUG = false;
private static ExternalAnnotationRepository sSingleton;
private final List<AnnotationsDatabase> mDatabases;
private ExternalAnnotationRepository(@NonNull List<AnnotationsDatabase> databases) {
mDatabases = databases;
}
@NonNull
public static synchronized ExternalAnnotationRepository get(@NonNull LintClient client) {
if (sSingleton == null) {
HashSet<AndroidLibrary> seen = Sets.newHashSet();
Collection<Project> projects = client.getKnownProjects();
List<File> files = Lists.newArrayListWithExpectedSize(2);
for (Project project : projects) {
if (project.isGradleProject()) {
Variant variant = project.getCurrentVariant();
AndroidProject model = project.getGradleProjectModel();
if (model != null && variant != null) {
Dependencies dependencies = variant.getMainArtifact().getDependencies();
for (AndroidLibrary library : dependencies.getLibraries()) {
addLibraries(files, library, seen);
}
}
}
}
File sdkAnnotations = client.findResource(SDK_ANNOTATIONS_PATH);
if (sdkAnnotations == null) {
// Until the SDK annotations are bundled in platform tools, provide
// a fallback for Gradle builds to point to a locally installed version
String path = System.getenv("SDK_ANNOTATIONS");
if (path != null) {
sdkAnnotations = new File(path);
if (!sdkAnnotations.exists()) {
sdkAnnotations = null;
}
}
}
if (sdkAnnotations != null) {
files.add(sdkAnnotations);
}
sSingleton = create(client, files);
}
return sSingleton;
}
@VisibleForTesting
@NonNull
static synchronized ExternalAnnotationRepository create(
@Nullable LintClient client,
@NonNull List<File> files) {
long begin;
if (DEBUG) {
begin = System.currentTimeMillis();
}
List<AnnotationsDatabase> databases = Lists.newArrayListWithExpectedSize(files.size());
for (File file : files) {
try {
AnnotationsDatabase database = getDatabase(file);
if (database != null) {
databases.add(database);
}
} catch (IOException ioe) {
if (client != null) {
client.log(ioe, "Could not read %1$s", file.getPath());
} else {
ioe.printStackTrace();
}
}
}
ExternalAnnotationRepository manager = new ExternalAnnotationRepository(databases);
if (DEBUG) {
long end = System.currentTimeMillis();
System.out.println("Initialization of annotations took " + (end - begin) + " ms");
}
return manager;
}
private static void addLibraries(
@NonNull List<File> result,
@NonNull AndroidLibrary library,
Set<AndroidLibrary> seen) {
if (seen.contains(library)) {
return;
}
seen.add(library);
// As of 1.2 this is available in the model:
// https://android-review.googlesource.com/#/c/137750/
// Switch over to this when it's in more common usage
// (until it is, we'll pay for failed proxying errors)
File zip = new File(library.getResFolder().getParent(), FN_ANNOTATIONS_ZIP);
if (zip.exists()) {
result.add(zip);
}
for (AndroidLibrary dependency : library.getLibraryDependencies()) {
addLibraries(result, dependency, seen);
}
}
@Nullable
private static AnnotationsDatabase getDatabase(
@NonNull LintClient client,
@NonNull File file) {
try {
return file.isFile() ? new AnnotationsDatabase(file) : null;
} catch (IOException ioe) {
client.log(ioe, "Could not read %1$s", file.getPath());
return null;
}
}
@VisibleForTesting
@Nullable
static AnnotationsDatabase getDatabase(@NonNull File file) throws IOException {
return file.exists() ? new AnnotationsDatabase(file) : null;
}
@Nullable
private static AnnotationsDatabase getDatabase(
@NonNull LintClient client,
@NonNull AndroidLibrary library) {
// As of 1.2 this is available in the model:
// https://android-review.googlesource.com/#/c/137750/
// Switch over to this when it's in more common usage
// (until it is, we'll pay for failed proxying errors)
File zip = new File(library.getResFolder().getParent(), FN_ANNOTATIONS_ZIP);
return getDatabase(client, zip);
}
// ---- Query methods ----
@Nullable
public ResolvedAnnotation getAnnotation(@NonNull ResolvedMethod method, @NonNull String type) {
for (AnnotationsDatabase database : mDatabases) {
ResolvedAnnotation annotation = database.getAnnotation(method, type);
if (annotation != null) {
return annotation;
}
}
return null;
}
@Nullable
public Collection<ResolvedAnnotation> getAnnotations(@NonNull ResolvedMethod method) {
for (AnnotationsDatabase database : mDatabases) {
Collection<ResolvedAnnotation> annotations = database.getAnnotations(method);
if (annotations != null) {
return annotations;
}
}
return null;
}
@Nullable
public ResolvedAnnotation getAnnotation(@NonNull ResolvedMethod method,
int parameterIndex, @NonNull String type) {
for (AnnotationsDatabase database : mDatabases) {
ResolvedAnnotation annotation = database.getAnnotation(method, parameterIndex, type);
if (annotation != null) {
return annotation;
}
}
return null;
}
@Nullable
public Collection<ResolvedAnnotation> getAnnotations(
@NonNull ResolvedMethod method,
int parameterIndex) {
for (AnnotationsDatabase database : mDatabases) {
Collection<ResolvedAnnotation> annotations = database.getAnnotations(method,
parameterIndex);
if (annotations != null) {
return annotations;
}
}
return null;
}
@Nullable
public ResolvedAnnotation getAnnotation(@NonNull ResolvedClass cls, @NonNull String type) {
for (AnnotationsDatabase database : mDatabases) {
ResolvedAnnotation annotation = database.getAnnotation(cls, type);
if (annotation != null) {
return annotation;
}
}
return null;
}
@Nullable
public Collection<ResolvedAnnotation> getAnnotations(@NonNull ResolvedClass cls) {
for (AnnotationsDatabase database : mDatabases) {
Collection<ResolvedAnnotation> annotations = database.getAnnotations(cls);
if (annotations != null) {
return annotations;
}
}
return null;
}
@Nullable
public ResolvedAnnotation getAnnotation(@NonNull ResolvedField field, @NonNull String type) {
for (AnnotationsDatabase database : mDatabases) {
ResolvedAnnotation annotation = database.getAnnotation(field, type);
if (annotation != null) {
return annotation;
}
}
return null;
}
@Nullable
public Collection<ResolvedAnnotation> getAnnotations(@NonNull ResolvedField field) {
for (AnnotationsDatabase database : mDatabases) {
Collection<ResolvedAnnotation> annotations = database.getAnnotations(field);
if (annotations != null) {
return annotations;
}
}
return null;
}
@Nullable
public Collection<ResolvedAnnotation> getAnnotations(@NonNull ResolvedAnnotation cls) {
for (AnnotationsDatabase database : mDatabases) {
Collection<ResolvedAnnotation> annotations = database.getAnnotations(cls);
if (annotations != null) {
return annotations;
}
}
return null;
}
@Nullable
public ResolvedAnnotation getAnnotation(@NonNull ResolvedPackage pkg, @NonNull String type) {
for (AnnotationsDatabase database : mDatabases) {
ResolvedAnnotation annotation = database.getAnnotation(pkg, type);
if (annotation != null) {
return annotation;
}
}
return null;
}
@Nullable
public Collection<ResolvedAnnotation> getAnnotations(@NonNull ResolvedPackage pkg) {
for (AnnotationsDatabase database : mDatabases) {
Collection<ResolvedAnnotation> annotations = database.getAnnotations(pkg);
if (annotations != null) {
return annotations;
}
}
return null;
}
// ---- Reading from storage ----
private static final Pattern XML_SIGNATURE = Pattern.compile(
// Class (FieldName | Type? Name(ArgList) Argnum?)
"(\\S+) (\\S+|((.*)\\s+)?(\\S+)\\((.*)\\)( \\d+)?)");
/** Map from class fully qualified name to the class annotations info */
// Query database
private static class ClassInfo {
public List<ResolvedAnnotation> annotations;
public Multimap<String,MethodInfo> methods;
public Map<String,FieldInfo> fields;
}
private static class MethodInfo {
public String parameters;
public boolean constructor;
public List<ResolvedAnnotation> annotations;
public Multimap<Integer,ResolvedAnnotation> parameterAnnotations;
}
private static class FieldInfo {
public List<ResolvedAnnotation> annotations;
}
/** An {@linkplain AnnotationsDatabase} corresponds to a single external annotations .zip
* file (or if in the dev tree, a corresponding directory tree.
* <p>
* The SDK has an annotations database, and AAR libraries can also supply individual databases.
* The {@linkplain ExternalAnnotationRepository} class manages all of these and performs lookup
* into the various databases through a single entrypoint.
* */
static class AnnotationsDatabase {
AnnotationsDatabase(@NonNull File file) throws IOException {
String path = file.getPath();
if (path.endsWith(DOT_JAR) || path.endsWith(FN_ANNOTATIONS_ZIP)) {
initializeFromJar(file);
} else {
assert file.isDirectory() : file;
initializeFromDirectory(file);
}
}
// ---- Query methods ----
@Nullable
public ResolvedAnnotation getAnnotation(@NonNull ResolvedMethod method,
@NonNull String type) {
MethodInfo m = findMethod(method);
if (m == null) {
return null;
}
if (m.annotations != null) {
for (ResolvedAnnotation annotation : m.annotations) {
if (type.equals(annotation.getSignature())) {
return annotation;
}
}
}
return null;
}
@Nullable
public List<ResolvedAnnotation> getAnnotations(@NonNull ResolvedMethod method) {
MethodInfo m = findMethod(method);
if (m == null) {
return null;
}
return m.annotations;
}
@Nullable
public ResolvedAnnotation getAnnotation(@NonNull ResolvedMethod method,
int parameterIndex, @NonNull String type) {
MethodInfo m = findMethod(method);
if (m == null) {
return null;
}
if (m.parameterAnnotations != null) {
Collection<ResolvedAnnotation> annotations = m.parameterAnnotations.get(parameterIndex);
if (annotations != null) {
for (ResolvedAnnotation annotation : annotations) {
if (type.equals(annotation.getSignature())) {
return annotation;
}
}
}
}
return null;
}
@Nullable
public Collection<ResolvedAnnotation> getAnnotations(
@NonNull ResolvedMethod method,
int parameterIndex) {
MethodInfo m = findMethod(method);
if (m == null) {
return null;
}
if (m.parameterAnnotations != null) {
return m.parameterAnnotations.get(parameterIndex);
}
return m.annotations;
}
@Nullable
public ResolvedAnnotation getAnnotation(@NonNull ResolvedClass cls, @NonNull String type) {
ClassInfo c = findClass(cls);
if (c == null) {
return null;
}
if (c.annotations != null) {
for (ResolvedAnnotation annotation : c.annotations) {
if (type.equals(annotation.getSignature())) {
return annotation;
}
}
}
return null;
}
@Nullable
public List<ResolvedAnnotation> getAnnotations(@NonNull ResolvedClass cls) {
ClassInfo c = findClass(cls);
if (c == null) {
return null;
}
return c.annotations;
}
@Nullable
public List<ResolvedAnnotation> getAnnotations(@NonNull ResolvedAnnotation cls) {
ClassInfo c = findClass(cls);
if (c == null) {
return null;
}
return c.annotations;
}
@Nullable
public ResolvedAnnotation getAnnotation(@NonNull ResolvedPackage pkg, @NonNull String type) {
ClassInfo c = findPackage(pkg);
if (c == null) {
return null;
}
if (c.annotations != null) {
for (ResolvedAnnotation annotation : c.annotations) {
if (type.equals(annotation.getSignature())) {
return annotation;
}
}
}
return null;
}
@Nullable
public List<ResolvedAnnotation> getAnnotations(@NonNull ResolvedPackage pkg) {
ClassInfo c = findPackage(pkg);
if (c == null) {
return null;
}
return c.annotations;
}
@Nullable
public ResolvedAnnotation getAnnotation(@NonNull ResolvedField field, @NonNull String type) {
FieldInfo f = findField(field);
if (f == null) {
return null;
}
if (f.annotations != null) {
for (ResolvedAnnotation annotation : f.annotations) {
if (type.equals(annotation.getSignature())) {
return annotation;
}
}
}
return null;
}
@Nullable
public List<ResolvedAnnotation> getAnnotations(@NonNull ResolvedField field) {
FieldInfo f = findField(field);
if (f == null) {
return null;
}
return f.annotations;
}
// ---- Initialization ----
private void initializeFromDirectory(File file) throws IOException {
if (file.isDirectory()) {
File[] files = file.listFiles();
if (files != null) {
for (File f : files) {
initializeFromDirectory(f);
}
}
} else if (file.getPath().endsWith(FN_ANNOTATIONS_XML)) {
String xml = Files.toString(file, Charsets.UTF_8);
initializePackage(xml, file.getPath());
}
}
private void initializeFromJar(File file) throws IOException {
// Reads in an existing annotations jar and merges in entries found there
// with the annotations analyzed from source.
JarInputStream zis = null;
try {
@SuppressWarnings("IOResourceOpenedButNotSafelyClosed")
FileInputStream fis = new FileInputStream(file);
zis = new JarInputStream(fis);
ZipEntry entry = zis.getNextEntry();
while (entry != null) {
if (entry.getName().endsWith(".xml")) {
byte[] bytes = ByteStreams.toByteArray(zis);
String xml = new String(bytes, Charsets.UTF_8);
initializePackage(xml, entry.getName());
}
entry = zis.getNextEntry();
}
} finally {
try {
Closeables.close(zis, true);
} catch (IOException e) {
// pass
}
}
}
/**
* Takes the XML contents of an annotations.xml file, parses it and initialize
* the necessary data structures
*/
private void initializePackage(@NonNull String xml, @NonNull String path)
throws IOException {
try {
Document document = XmlUtils.parseDocument(xml, false);
Element root = document.getDocumentElement();
String rootTag = root.getTagName();
assert rootTag.equals("root") : rootTag;
for (Element item : LintUtils.getChildren(root)) {
String signature = item.getAttribute(ATTR_NAME);
if (signature == null || signature.equals("null")) {
continue; // malformed item
}
signature = XmlUtils.fromXmlAttributeValue(signature);
Matcher matcher = XML_SIGNATURE.matcher(signature);
if (matcher.matches()) {
String containingClass = matcher.group(1);
if (containingClass == null) {
throw new IOException("Could not find class for " + signature);
}
String methodName = matcher.group(5);
if (methodName != null) {
String type = matcher.group(4);
boolean isConstructor = type == null;
String parameters = matcher.group(6);
mergeMethodOrParameter(item, matcher, containingClass, methodName,
isConstructor, parameters);
} else {
String fieldName = matcher.group(2);
mergeField(item, containingClass, fieldName);
}
} else if (signature.indexOf(' ') == -1 && signature.indexOf('.') != -1) {
mergeClass(item, signature);
} else {
throw new IOException("No merge match for signature " + signature);
}
}
} catch (Exception e) {
throw new IOException("Could not parse XML from " + path);
}
}
// SDK annotations
private Map<String,ClassInfo> mClassMap = Maps.newHashMapWithExpectedSize(800);
@Nullable
private ClassInfo findClass(@NonNull ResolvedClass cls) {
return mClassMap.get(cls.getName());
}
@Nullable
private ClassInfo findClass(@NonNull ResolvedAnnotation cls) {
return mClassMap.get(cls.getName());
}
private ClassInfo findPackage(@NonNull ResolvedPackage pkg) {
return mClassMap.get(pkg.getName() +".package-info");
}
@Nullable
private MethodInfo findMethod(@NonNull ResolvedMethod method) {
ClassInfo c = findClass(method.getContainingClass());
if (c == null) {
return null;
}
if (c.methods == null) {
return null;
}
Collection<MethodInfo> methods = c.methods.get(method.getName());
if (methods == null) {
return null;
}
boolean constructor = method.isConstructor();
for (MethodInfo m : methods) {
if (constructor != m.constructor) {
continue;
}
// Check parameter types
// TODO: Perform faster parameter check! This is inefficient
// Stash parameter count such that I can quickly compare the two
String signature = m.parameters;
int index = 0;
boolean matches = true;
for (int i = 0, n = method.getArgumentCount(); i < n; i++) {
String parameterType = method.getArgumentType(i).getSignature();
int length = parameterType.indexOf('<');
if (length == -1) {
length = parameterType.length();
}
if (!signature.regionMatches(false, index, parameterType, 0, length)) {
// Check if we have a varargs match: x... vs x[]
if (length <= 3 || index <= 3 || ((parameterType.charAt(length - 1) != '.')
&& (signature.length() < index + length
|| signature.charAt(index + length - 1) != '.'))
|| !isVarArgsMatch(signature, index, parameterType, length)) {
matches = false;
break;
}
}
index += length;
if (i < n - 1) {
if (index == signature.length()) {
matches = false;
break;
} else if (signature.charAt(index) == '<') {
// Skip raw types
int balance = 1;
for (int j = index + 1, max = signature.length(); j < max; j++) {
char ch = signature.charAt(j);
if (ch == '<') {
balance++;
} else if (ch == '>') {
balance--;
if (balance == 0) {
index = j + 1;
break;
}
}
}
if (balance > 0) {
matches = false;
break;
}
} else if (signature.charAt(index) != ',') {
matches = false;
break;
}
}
index++; // skip comma
}
if (matches) {
return m;
}
}
return null;
}
/**
* Checks whether the string at parameterType(0,length) and signature(index,index+length)
* are the same, except with one possibly ending with [] and the other with ... - if
* so these should be taken to match
*/
private static boolean isVarArgsMatch(String signature, int index, String parameterType,
int length) {
return parameterType.regionMatches(false, length - 3, "...", 0, 3) &&
signature.regionMatches(false, index + length - 3, "[]", 0, 2) &&
parameterType.regionMatches(false, 0, signature, index, length - 3)
|| parameterType.regionMatches(false, length - 2, "[]", 0, 2) &&
signature.regionMatches(false, index + length - 2, "...", 0, 3) &&
parameterType.regionMatches(false, 0, signature, index, length - 2);
}
@Nullable
private FieldInfo findField(@NonNull ResolvedField field) {
ClassInfo c = findClass(field.getContainingClass());
if (c == null) {
return null;
}
if (c.fields == null) {
return null;
}
return c.fields.get(field.getName());
}
@NonNull
private MethodInfo createMethod(@NonNull String containingClass, @NonNull String methodName,
boolean constructor, @NonNull String parameters) {
ClassInfo cls = createClass(containingClass);
if (cls.methods != null) {
Collection<MethodInfo> methods = cls.methods.get(methodName);
if (methods != null) {
for (MethodInfo method : methods) {
if (parameters.equals(method.parameters)
&& constructor == method.constructor) {
return method;
}
}
}
}
MethodInfo method = new MethodInfo();
method.parameters = parameters;
method.constructor = constructor;
if (cls.methods == null) {
cls.methods = ArrayListMultimap.create(); // TODO: Size me
}
cls.methods.put(methodName, method);
return method;
}
@NonNull
private ClassInfo createClass(@NonNull String containingClass) {
ClassInfo cls = mClassMap.get(containingClass);
if (cls == null) {
cls = new ClassInfo();
mClassMap.put(containingClass, cls);
}
return cls;
}
@NonNull
private FieldInfo createField(@NonNull String containingClass, @NonNull String fieldName) {
ClassInfo cls = createClass(containingClass);
if (cls.fields != null) {
FieldInfo field = cls.fields.get(fieldName);
if (field != null) {
return field;
}
}
FieldInfo field = new FieldInfo();
if (cls.fields == null) {
cls.fields = Maps.newHashMap(); // TODO: Size me
}
cls.fields.put(fieldName, field);
return field;
}
private void mergeMethodOrParameter(Element item, Matcher matcher, String containingClass,
String methodName, boolean constructor, String parameters) {
parameters = fixParameterString(parameters);
MethodInfo method = createMethod(containingClass, methodName, constructor, parameters);
List<ResolvedAnnotation> annotations = createAnnotations(item);
String argNum = matcher.group(7);
if (argNum != null) {
argNum = argNum.trim();
int parameter = Integer.parseInt(argNum);
if (method.parameterAnnotations == null) {
// Do I know the parameter count here?
int parameterCount = 4;
method.parameterAnnotations = ArrayListMultimap
.create(parameterCount, annotations.size());
}
for (ResolvedAnnotation annotation : annotations) {
method.parameterAnnotations.put(parameter, annotation);
}
} else {
if (method.annotations == null) {
method.annotations = Lists.newArrayListWithExpectedSize(annotations.size());
}
method.annotations.addAll(annotations);
}
}
private void mergeField(Element item, String containingClass, String fieldName) {
FieldInfo field = createField(containingClass, fieldName);
List<ResolvedAnnotation> annotations = createAnnotations(item);
if (field.annotations == null) {
field.annotations = Lists.newArrayListWithExpectedSize(annotations.size());
}
field.annotations.addAll(annotations);
}
private void mergeClass(Element item, String containingClass) {
ClassInfo cls = createClass(containingClass);
List<ResolvedAnnotation> annotations = createAnnotations(item);
if (cls.annotations == null) {
cls.annotations = Lists.newArrayListWithExpectedSize(annotations.size());
}
cls.annotations.addAll(annotations);
}
private List<ResolvedAnnotation> createAnnotations(Element itemElement) {
List<Element> children = getChildren(itemElement);
List<ResolvedAnnotation> result = Lists.newArrayListWithExpectedSize(children.size());
for (Element annotationElement : children) {
ResolvedAnnotation annotation = createAnnotation(annotationElement);
result.add(annotation);
}
return result;
}
private static class ResolvedExternalAnnotation extends ResolvedAnnotation {
@NonNull
private String mSignature;
@Nullable
private List<Value> mValues;
public ResolvedExternalAnnotation(@NonNull String signature) {
mSignature = signature;
}
void addValue(@NonNull Value value) {
if (mValues == null) {
mValues = Lists.newArrayList();
}
mValues.add(value);
}
@NonNull
@Override
public String getName() {
return mSignature;
}
@NonNull
@Override
public String getSignature() {
return mSignature;
}
@Override
public int getModifiers() {
return Modifier.PUBLIC;
}
@NonNull
@Override
public Iterable<ResolvedAnnotation> getAnnotations() {
return Collections.emptyList();
}
@Override
public boolean matches(@NonNull String name) {
return mSignature.equals(name);
}
@NonNull
@Override
public TypeDescriptor getType() {
return new DefaultTypeDescriptor(mSignature);
}
@Nullable
@Override
public ResolvedClass getClassType() {
// No nested annotations in the database
return null;
}
@NonNull
@Override
public List<Value> getValues() {
return mValues == null ? Collections.<Value>emptyList() : mValues;
}
}
private Map<String, ResolvedExternalAnnotation> mMarkerAnnotations = Maps.newHashMapWithExpectedSize(30);
private ResolvedAnnotation createAnnotation(Element annotationElement) {
String tagName = annotationElement.getTagName();
assert tagName.equals("annotation") : tagName;
String name = annotationElement.getAttribute(ATTR_NAME);
assert name != null && !name.isEmpty();
ResolvedExternalAnnotation annotation = mMarkerAnnotations.get(name);
if (annotation != null) {
return annotation;
}
annotation = new ResolvedExternalAnnotation(name);
List<Element> valueElements = getChildren(annotationElement);
if (valueElements.isEmpty()
// Permission annotations are sometimes used as marker annotations (on
// parameters) but that shouldn't let us conclude that any future
// permission annotations are
&& !name.startsWith(PERMISSION_ANNOTATION)) {
mMarkerAnnotations.put(name, annotation);
return annotation;
}
for (Element valueElement : valueElements) {
if (valueElement.getTagName().equals("val")) {
String valueName = valueElement.getAttribute(ATTR_NAME);
String valueString = valueElement.getAttribute("val");
if (!valueName.isEmpty() && !valueString.isEmpty()) {
// Guess type
Object value;
if (valueString.equals(VALUE_TRUE)) {
value = true;
} else if (valueString.equals(VALUE_FALSE)) {
value = false;
} else if (valueString.startsWith("\"") && valueString.endsWith("\"") &&
valueString.length() >= 2) {
value = valueString.substring(1, valueString.length() - 1);
} else if (valueString.startsWith("{") && valueString.endsWith("}")) {
// Array of values
String listString = valueString.substring(1, valueString.length() - 1);
// We don't know the types, but we'll assume that they're either
// all strings (the most common array type in our annotations), or
// field references. We can't know the types of the fields; it's
// not part of the annotation metadata. We'll place them in an Object[]
// for now.
boolean allStrings = true;
Splitter splitter = Splitter.on(',').omitEmptyStrings().trimResults();
List<Object> result = Lists.newArrayList();
for (String reference : splitter.split(listString)) {
if (reference.startsWith("\"")) {
result.add(reference.substring(1, reference.length() - 1));
} else {
result.add(new ResolvedExternalField(reference));
allStrings = false;
}
}
if (allStrings) {
value = result.toArray(new String[result.size()]);
} else {
value = result.toArray();
}
// We don't know the actual type of these fields; we'll assume they're
// a special form of
} else if (Character.isDigit(valueString.charAt(0))) {
try {
if (valueString.contains(".")) {
value = Double.parseDouble(valueString);
} else {
value = Long.parseLong(valueString);
}
} catch (NumberFormatException nufe) {
value = valueString;
}
} else {
value = valueString; // unknown type
}
annotation.addValue(new Value(valueName, value));
}
}
}
return annotation;
}
}
/** Special implementation of a {@link ResolvedField} which can
* do equality comparisons with {@link EcjParser.EcjResolvedField} */
private static class ResolvedExternalField extends ResolvedField {
private final String mSignature;
public ResolvedExternalField(String signature) {
mSignature = signature;
assert mSignature.indexOf(' ') == -1 : '"' + mSignature + '"';
}
@NonNull
@Override
public String getName() {
return mSignature.substring(mSignature.lastIndexOf('.') + 1);
}
@Override
public String getSignature() {
return mSignature;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof ResolvedExternalField) {
return mSignature.equals(((ResolvedExternalField)obj).mSignature);
} else if (obj instanceof ResolvedField) {
ResolvedField field = (ResolvedField)obj;
if (mSignature.endsWith(field.getName())) {
String signature = field.getContainingClass().getSignature() +
"." + field.getName();
return mSignature.equals(signature);
}
return false;
} else {
return false;
}
}
@Override
public int hashCode() {
return mSignature.hashCode();
}
@Override
public int getModifiers() {
return 0;
}
@Override
public boolean matches(@NonNull String name) {
return mSignature.equals(name);
}
@NonNull
@Override
public TypeDescriptor getType() {
return new DefaultTypeDescriptor(mSignature);
}
@NonNull
@Override
public ResolvedClass getContainingClass() {
throw new UnsupportedOperationException();
}
@Override
public String getContainingClassName() {
return mSignature.substring(0, mSignature.lastIndexOf('.'));
}
@Nullable
@Override
public Object getValue() {
return null;
}
@NonNull
@Override
public Iterable<ResolvedAnnotation> getAnnotations() {
return Collections.emptyList();
}
}
@NonNull
private static List<Element> getChildren(@NonNull Element element) {
NodeList itemList = element.getChildNodes();
int length = itemList.getLength();
if (length == 0) {
return Collections.emptyList();
}
List<Element> result = new ArrayList<Element>(Math.max(5, length / 2 + 1));
for (int i = 0; i < length; i++) {
Node node = itemList.item(i);
if (node.getNodeType() != Node.ELEMENT_NODE) {
continue;
}
result.add((Element) node);
}
return result;
}
// The parameter declaration used in XML files should not have duplicated spaces,
// and there should be no space after commas (we can't however strip out all spaces,
// since for example the spaces around the "extends" keyword needs to be there in
// types like Map<String,? extends Number>
private static String fixParameterString(String parameters) {
return parameters.replace(" ", " ").replace(", ", ",");
}
/** For test usage only */
@VisibleForTesting
static synchronized void set(ExternalAnnotationRepository singleton) {
assert singleton == null || sSingleton == null;
sSingleton = singleton;
}
}