ComponentProcessor.java

Go to the documentation of this file.

// -*- mode: java; c-basic-offset: 2; -*-
// Copyright 2009-2011 Google, All Rights reserved
// Copyright 2011-2019 MIT, All rights reserved
// Released under the Apache License, Version 2.0
// http://www.apache.org/licenses/LICENSE-2.0
 
package com.google.appinventor.components.scripts;
 
import com.google.appinventor.components.annotations.DesignerComponent;
import com.google.appinventor.components.annotations.DesignerProperty;
import com.google.appinventor.components.annotations.IsColor;
import com.google.appinventor.components.annotations.PropertyCategory;
import com.google.appinventor.components.annotations.SimpleEvent;
import com.google.appinventor.components.annotations.SimpleFunction;
import com.google.appinventor.components.annotations.SimpleObject;
import com.google.appinventor.components.annotations.SimpleProperty;
import com.google.appinventor.components.annotations.SimpleBroadcastReceiver;
import com.google.appinventor.components.annotations.UsesActivityMetadata;
import com.google.appinventor.components.annotations.UsesApplicationMetadata;
import com.google.appinventor.components.annotations.UsesAssets;
import com.google.appinventor.components.annotations.UsesLibraries;
import com.google.appinventor.components.annotations.UsesNativeLibraries;
import com.google.appinventor.components.annotations.UsesPermissions;
import com.google.appinventor.components.annotations.UsesActivities;
import com.google.appinventor.components.annotations.UsesBroadcastReceivers;
import com.google.appinventor.components.annotations.UsesContentProviders;
import com.google.appinventor.components.annotations.UsesServices;
import com.google.appinventor.components.annotations.androidmanifest.ActivityElement;
import com.google.appinventor.components.annotations.androidmanifest.ReceiverElement;
import com.google.appinventor.components.annotations.androidmanifest.IntentFilterElement;
import com.google.appinventor.components.annotations.androidmanifest.MetaDataElement;
import com.google.appinventor.components.annotations.androidmanifest.ActionElement;
import com.google.appinventor.components.annotations.androidmanifest.DataElement;
import com.google.appinventor.components.annotations.androidmanifest.CategoryElement;
import com.google.appinventor.components.annotations.androidmanifest.ServiceElement;
import com.google.appinventor.components.annotations.androidmanifest.ProviderElement;
import com.google.appinventor.components.annotations.androidmanifest.PathPermissionElement;
import com.google.appinventor.components.annotations.androidmanifest.GrantUriPermissionElement;
import com.google.appinventor.components.common.PropertyTypeConstants;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
 
import java.io.IOException;
import java.io.Writer;
 
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
 
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.AnnotationValue;
import javax.lang.model.element.AnnotationValueVisitor;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.ExecutableType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.Elements;
import javax.lang.model.util.SimpleTypeVisitor7;
import javax.lang.model.util.Types;
 
import java.lang.annotation.Annotation;
 
import java.lang.reflect.InvocationTargetException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
import javax.tools.Diagnostic;
import javax.tools.Diagnostic.Kind;
import javax.tools.FileObject;
import javax.tools.StandardLocation;
 
public abstract class ComponentProcessor extends AbstractProcessor {
  private static final String OUTPUT_PACKAGE = "";
 
  private static final String MISSING_SIMPLE_PROPERTY_ANNOTATION =
      "Designer property %s does not have a corresponding @SimpleProperty annotation.";
  private static final String BOXED_TYPE_ERROR =
      "Found use of boxed type %s. Please use the primitive type %s instead";
 
  // Returned by getSupportedAnnotationTypes()
  private static final Set<String> SUPPORTED_ANNOTATION_TYPES = ImmutableSet.of(
      "com.google.appinventor.components.annotations.DesignerComponent",
      "com.google.appinventor.components.annotations.DesignerProperty",
      "com.google.appinventor.components.annotations.SimpleEvent",
      "com.google.appinventor.components.annotations.SimpleFunction",
      "com.google.appinventor.components.annotations.SimpleObject",
      "com.google.appinventor.components.annotations.SimpleProperty",
      // TODO(Will): Remove the following string once the deprecated
      //             @SimpleBroadcastReceiver annotation is removed. It should
      //             should remain for the time being because otherwise we'll break
      //             extensions currently using @SimpleBroadcastReceiver.
      "com.google.appinventor.components.annotations.SimpleBroadcastReceiver",
      "com.google.appinventor.components.annotations.UsesAssets",
      "com.google.appinventor.components.annotations.UsesLibraries",
      "com.google.appinventor.components.annotations.UsesNativeLibraries",
      "com.google.appinventor.components.annotations.UsesActivities",
      "com.google.appinventor.components.annotations.UsesBroadcastReceivers",
      "com.google.appinventor.components.annotations.UsesPermissions",
      "com.google.appinventor.components.annotations.UsesServices",
      "com.google.appinventor.components.annotations.UsesContentProviders");
 
  // Returned by getRwString()
  private static final String READ_WRITE = "read-write";
  private static final String READ_ONLY = "read-only";
  private static final String WRITE_ONLY = "write-only";
 
  // Must match buildserver.compiler.ARMEABI_V7A_SUFFIX
  private static final String ARMEABI_V7A_SUFFIX = "-v7a";
  // Must match buildserver.compiler.ARMEABI_V8A_SUFFIX
  private static final String ARM64_V8A_SUFFIX = "-v8a";
  // Must match buildserver.compiler.X86_64_SUFFIX
  private static final String X86_64_SUFFIX = "-x8a";
 
  private static final String TYPE_PLACEHOLDER = "%type%";
 
  private static final Map<String, String> BOXED_TYPES = new HashMap<>();
 
  static {
    BOXED_TYPES.put("java.lang.Boolean", "boolean");
    BOXED_TYPES.put("java.lang.Byte", "byte");
    BOXED_TYPES.put("java.lang.Char", "char");
    BOXED_TYPES.put("java.lang.Short", "short");
    BOXED_TYPES.put("java.lang.Integer", "int");
    BOXED_TYPES.put("java.lang.Long", "long");
    BOXED_TYPES.put("java.lang.Float", "float");
    BOXED_TYPES.put("java.lang.Double", "double");
  }
 
  // The next two fields are set in init().
  private Elements elementUtils;
  private Types typeUtils;
 
  // Set in process()
  protected Messager messager;
 
  private int pass = 0;
 
  protected final SortedMap<String, ComponentInfo> components = Maps.newTreeMap();
 
  private final List<String> componentTypes = Lists.newArrayList();
 
  private final Set<String> visitedTypes = new HashSet<>();
 
  protected final class Parameter {
    protected final String name;
 
    protected final String type;
 
    protected final boolean color;
 
    protected Parameter(String name, String type) {
      this(name, type, false);
    }
 
    protected Parameter(String name, String type, boolean color) {
      this.name = name;
      this.type = type;
      this.color = color;
    }
 
    protected String parameterToYailType(Parameter parameter) {
      return javaTypeToYailType(type);
    }
  }
 
  protected abstract static class Feature {
    private static final Pattern AT_SIGN = Pattern.compile("[^\\\\]@");
    private static final Pattern LINK_FORM = Pattern.compile("\\{@link ([A-Za-z]*#?)([A-Za-z]*)[^}]*}");
    private static final Pattern CODE_FORM = Pattern.compile("\\{@code ([^}]*)}");
 
    private final String featureType;
    protected final String name;
    protected String description;
    protected boolean defaultDescription = false;
    protected String longDescription;
    protected boolean userVisible;
    protected boolean deprecated;
 
    protected Feature(String name, String description, String longDescription, String featureType,
        boolean userVisible, boolean deprecated) {
      this.featureType = featureType;
      this.name = name;
      setDescription(description);
      setLongDescription(longDescription);
      this.userVisible = userVisible;
      this.deprecated = deprecated;
    }
 
    public boolean isDefaultDescription() {
      return defaultDescription;
    }
 
    public void setDescription(String description) {
      if (description == null || description.isEmpty()) {
        this.description = featureType + " for " + name;
        defaultDescription = true;
      } else {
        // Throw out the first @ or { and everything after it,
        // in order to strip out @param, @author, {@link ...}, etc.
        this.description = description.split("[@{]")[0].trim();
        defaultDescription = false;
      }
    }
 
    public void setLongDescription(String longDescription) {
      if (longDescription == null || longDescription.isEmpty()) {
        this.longDescription = this.description;
      } else if (longDescription.contains("@suppressdoc")) {
        this.longDescription = "";
      } else {
        this.longDescription = longDescription;
      }
      // Handle links
      Matcher linkMatcher = LINK_FORM.matcher(this.longDescription);
      StringBuffer sb = new StringBuffer();
      int lastEnd = 0;
      while (linkMatcher.find(lastEnd)) {
        sb.append(this.longDescription, lastEnd, linkMatcher.start());
        String clazz = linkMatcher.group(1);
        if (clazz.endsWith("#")) {
          clazz = clazz.substring(0, clazz.length() - 1);
        }
        if ("Form".equals(clazz)) {
          clazz = "Screen";
        }
        String func = linkMatcher.group(2);
        sb.append("[");
        if (!clazz.isEmpty()) {
          sb.append("`");
          sb.append(clazz);
          sb.append("`");
          if (!func.isEmpty()) {
            sb.append("'s ");
          }
        }
        if (!func.isEmpty()) {
          sb.append("`");
          sb.append(func);
          sb.append("`");
        }
        sb.append("](#");
        if (clazz.isEmpty()) {
          sb.append("%type%.");
        } else {
          sb.append(clazz);
          if (!func.isEmpty()) {
            sb.append(".");
          }
        }
        if (!func.isEmpty()) {
          sb.append(func);
        }
        sb.append(")");
        lastEnd = linkMatcher.end();
      }
      sb.append(this.longDescription.substring(lastEnd));
      this.longDescription = sb.toString();
      // Map {@code foo} to `foo`
      sb = new StringBuffer();
      Matcher codeMatcher = CODE_FORM.matcher(this.longDescription);
      lastEnd = 0;
      while (codeMatcher.find(lastEnd)) {
        sb.append(this.longDescription, lastEnd, codeMatcher.start());
        sb.append("`");
        sb.append(codeMatcher.group(1));
        sb.append("`");
        lastEnd = codeMatcher.end();
      }
      sb.append(this.longDescription.substring(lastEnd));
      this.longDescription = sb.toString();
      // Strip out the Javadoc annotations (@param, etc.) for end-user documentation
      Matcher m = AT_SIGN.matcher(this.longDescription);
      if (m.find()) {
        this.longDescription = this.longDescription.substring(0, m.start() + 1);
      }
      // Replace escaped @ with just @, e.g., so we can use @ in email address examples.
      this.longDescription = this.longDescription.replaceAll("\\\\@", "@").trim();
    }
 
    public String getLongDescription(ComponentInfo component) {
      if (longDescription == null || longDescription.isEmpty()) {
        return description;
      }
      String name = component.name.equals("Form") ? "Screen" : component.name;
      return longDescription.replaceAll("%type%", name).trim();
    }
 
    protected boolean isUserVisible() {
      return userVisible;
    }
 
    protected boolean isDeprecated() {
      return deprecated;
    }
  }
 
  protected abstract class ParameterizedFeature extends Feature {
    // Inherits name, description
    protected final List<Parameter> parameters;
 
    protected ParameterizedFeature(String name, String description, String longDescription,
        String feature, boolean userVisible, boolean deprecated) {
      super(name, description, longDescription, feature, userVisible, deprecated);
      parameters = Lists.newArrayList();
    }
 
    protected void addParameter(String name, String type) {
      parameters.add(new Parameter(name, type));
    }
 
    protected void addParameter(String name, String type, boolean color) {
      parameters.add(new Parameter(name, type, color));
    }
 
    protected String toParameterString() {
      StringBuilder sb = new StringBuilder();
      int count = 0;
      for (Parameter param : parameters) {
        sb.append(param.parameterToYailType(param));
        sb.append(" ");
        sb.append(param.name);
        if (++count != parameters.size()) {
          sb.append(", ");
        }
      }
      return new String(sb);
    }
  }
 
  protected final class Event extends ParameterizedFeature
      implements Cloneable, Comparable<Event> {
    // Inherits name, description, and parameters
 
    protected Event(String name, String description, String longDescription, boolean userVisible, boolean deprecated) {
      super(name, description, longDescription, "Event", userVisible, deprecated);
    }
 
    @Override
    public Event clone() {
      Event that = new Event(name, description, longDescription, userVisible, deprecated);
      for (Parameter p : parameters) {
        that.addParameter(p.name, p.type);
      }
      return that;
    }
 
    @Override
    public int compareTo(Event e) {
      return name.compareTo(e.name);
    }
  }
 
  protected final class Method extends ParameterizedFeature
      implements Cloneable, Comparable<Method> {
    // Inherits name, description, and parameters
    private String returnType;
    private boolean color;
 
    protected Method(String name, String description, String longDescription, boolean userVisible,
        boolean deprecated) {
      super(name, description, longDescription, "Method", userVisible, deprecated);
      // returnType defaults to null
    }
 
    protected String getReturnType() {
      return returnType;
    }
 
    protected boolean isColor() {
      return color;
    }
 
    @Override
    public Method clone() {
      Method that = new Method(name, description, longDescription, userVisible, deprecated);
      for (Parameter p : parameters) {
        that.addParameter(p.name, p.type);
      }
      that.returnType = returnType;
      return that;
    }
 
    @Override
    public int compareTo(Method f) {
      return name.compareTo(f.name);
    }
  }
 
  protected static final class Property extends Feature implements Cloneable {
    protected final String name;
    private PropertyCategory propertyCategory;
    private String type;
    private boolean readable;
    private boolean writable;
    private String componentInfoName;
    private boolean color;
 
    protected Property(String name, String description, String longDescription,
                       PropertyCategory category, boolean userVisible, boolean deprecated) {
      super(name, description, longDescription, "Property", userVisible, deprecated);
      this.name = name;
      this.propertyCategory = category;
      // type defaults to null
      // readable and writable default to false
    }
 
    @Override
    public Property clone() {
      Property that = new Property(name, description, longDescription, propertyCategory,
          isUserVisible(), isDeprecated());
      that.type = type;
      that.readable = readable;
      that.writable = writable;
      that.componentInfoName = componentInfoName;
      that.color = color;
      return that;
    }
 
    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("<Property name: ");
      sb.append(name);
      sb.append(", type: ");
      sb.append(type);
      if (readable) {
        sb.append(" readable");
      }
      if (writable) {
        sb.append(" writable");
      }
      sb.append(">");
      return sb.toString();
    }
 
    protected String getDescription() {
      return description;
    }
 
    protected String getType() {
      return type;
    }
 
    protected boolean isReadable() {
      return readable;
    }
 
    protected boolean isWritable() {
      return writable;
    }
 
    protected boolean isColor() {
      return color;
    }
 
    protected String getRwString() {
      if (readable) {
        if (writable) {
          return READ_WRITE;
        } else {
          return READ_ONLY;
        }
      } else {
        if (!writable) {
          throw new RuntimeException("Property " + name +
                                     " is neither readable nor writable");
        }
        return WRITE_ONLY;
      }
    }
  }
 
  protected final class ComponentInfo extends Feature {
    // Inherits name and description
    protected final Set<String> permissions;
 
    protected final Map<String, String[]> conditionalPermissions;
 
    protected final Map<String, String[]> conditionalBroadcastReceivers;
 
    protected final Map<String, String[]> conditionalServices;
 
    protected final Map<String, String[]> conditionalContentProviders;
 
    protected final Set<String> libraries;
 
    protected final Set<String> nativeLibraries;
 
    protected final Set<String> assets;
 
    protected final Set<String> activities;
 
    protected final Set<String> metadata;
 
    protected final Set<String> activityMetadata;
 
    protected final Set<String> broadcastReceivers;
 
    protected final Set<String> services;
 
    protected final Set<String> contentProviders;
 
    protected final Set<String> classNameAndActionsBR;
 
    protected final SortedMap<String, DesignerProperty> designerProperties;
 
    protected final SortedMap<String, Property> properties;
 
    protected final SortedMap<String, Method> methods;
 
    protected final SortedMap<String, Event> events;
 
    protected final boolean abstractClass;
 
    protected final String displayName;
 
    protected final String type;
    protected boolean external;
 
    private String helpDescription;  // Shorter popup description
    private String helpUrl;  // Custom help URL for extensions
    private String category;
    private String categoryString;
    private boolean simpleObject;
    private boolean designerComponent;
    private int version;
    private boolean showOnPalette;
    private boolean nonVisible;
    private String iconName;
    private int androidMinSdk;
    private String versionName;
    private String dateBuilt;
 
    protected ComponentInfo(Element element) {
      super(element.getSimpleName().toString(),  // Short name
            elementUtils.getDocComment(element),
            elementUtils.getDocComment(element),
            "Component", false, elementUtils.isDeprecated(element));
      type = element.asType().toString();
      displayName = getDisplayNameForComponentType(name);
      permissions = Sets.newHashSet();
      conditionalPermissions = Maps.newTreeMap();
      conditionalBroadcastReceivers = Maps.newTreeMap();
      conditionalServices = Maps.newTreeMap();
      conditionalContentProviders = Maps.newTreeMap();
      libraries = Sets.newHashSet();
      nativeLibraries = Sets.newHashSet();
      assets = Sets.newHashSet();
      activities = Sets.newHashSet();
      metadata = Sets.newHashSet();
      activityMetadata = Sets.newHashSet();
      broadcastReceivers = Sets.newHashSet();
      services = Sets.newHashSet();
      contentProviders = Sets.newHashSet();
      classNameAndActionsBR = Sets.newHashSet();
      designerProperties = Maps.newTreeMap();
      properties = Maps.newTreeMap();
      methods = Maps.newTreeMap();
      events = Maps.newTreeMap();
      abstractClass = element.getModifiers().contains(Modifier.ABSTRACT);
      external = false;
      versionName = null;
      dateBuilt = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ").format(new Date());
      for (AnnotationMirror am : element.getAnnotationMirrors()) {
        DeclaredType dt = am.getAnnotationType();
        String annotationName = am.getAnnotationType().toString();
        if (annotationName.equals(SimpleObject.class.getName())) {
          simpleObject = true;
          SimpleObject simpleObjectAnnotation = element.getAnnotation(SimpleObject.class);
          external = simpleObjectAnnotation.external();
        }
        if (annotationName.equals(DesignerComponent.class.getName())) {
          designerComponent = true;
          DesignerComponent designerComponentAnnotation =
              element.getAnnotation(DesignerComponent.class);
          Map values = elementUtils.getElementValuesWithDefaults(am);
          for (Map.Entry entry : (Set<Map.Entry>) values.entrySet()) {
            if (((ExecutableElement) entry.getKey()).getSimpleName().contentEquals("dateBuilt")) {
              // ------------------- Ulli ---------------------------------
// Folgende Zeilen eingefügt
String tempDate = "" + entry.getValue(); // get value from entry
if (tempDate.length() > 2) {
  tempDate = tempDate.substring(1, tempDate.length() - 1); // strip off \" at start and end
  dateBuilt = tempDate;
}
// Ulli Ende
 
              entry.setValue(new AnnotationValue() {
                @Override
                public Object getValue() {
                  return dateBuilt;
                }
 
                @Override
                public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) {
                  return v.visit(this, p);
                }
 
                @Override
                public String toString() {
                  return "\"" + dateBuilt + "\"";
                }
              });
            }
          }
 
          // Override javadoc description with explicit description
          // if provided.
          String explicitDescription = designerComponentAnnotation.description();
          if (!explicitDescription.isEmpty()) {
            setDescription(explicitDescription);
          }
 
          // Set helpDescription to the designerHelpDescription field if
          // provided; otherwise, use description
          helpDescription = designerComponentAnnotation.designerHelpDescription();
          if (helpDescription.isEmpty()) {
            helpDescription = description;
          }
          helpUrl = designerComponentAnnotation.helpUrl();
          if (!helpUrl.startsWith("http:") && !helpUrl.startsWith("https:")) {
            helpUrl = "";  // only accept http: or https: URLs (e.g., no javascript:)
          }
 
          category = designerComponentAnnotation.category().getName();
          categoryString = designerComponentAnnotation.category().toString();
          version = designerComponentAnnotation.version();
          showOnPalette = designerComponentAnnotation.showOnPalette();
          nonVisible = designerComponentAnnotation.nonVisible();
          iconName = designerComponentAnnotation.iconName();
          androidMinSdk = designerComponentAnnotation.androidMinSdk();
          versionName = designerComponentAnnotation.versionName();
          userVisible = designerComponentAnnotation.showOnPalette();
        }
      }
    }
 
    protected String getHelpDescription() {
      return helpDescription;
    }
 
    protected String getHelpUrl() {
      return helpUrl;
    }
 
    protected String getCategory() {
      return category;
    }
 
    protected String getCategoryString() {
      return categoryString;
    }
 
    protected int getVersion() {
      return version;
    }
 
    protected boolean getShowOnPalette() {
      return showOnPalette;
    }
 
    protected boolean getNonVisible() {
      return nonVisible;
    }
 
    protected boolean getExternal() {
      return external;
    }
 
    protected String getIconName() {
      return iconName;
    }
 
    protected int getAndroidMinSdk() {
      return androidMinSdk;
    }
 
    protected String getVersionName() {
      return versionName;
    }
 
    protected String getDateBuilt() {
      return dateBuilt;
    }
 
    private String getDisplayNameForComponentType(String componentTypeName) {
      // Users don't know what a 'Form' is.  They know it as a 'Screen'.
      return "Form".equals(componentTypeName) ? "Screen" : componentTypeName;
    }
 
    protected String getName() {
      if (name.equals("Form")) {
        return "Screen";
      } else {
        return name;
      }
    }
 
  }
 
  @Override
  public Set<String> getSupportedAnnotationTypes() {
    return SUPPORTED_ANNOTATION_TYPES;
  }
 
  @Override
  public SourceVersion getSupportedSourceVersion() {
    return SourceVersion.RELEASE_7;
  }
 
  @Override
  public void init(ProcessingEnvironment processingEnv) {
    super.init(processingEnv);
    elementUtils = processingEnv.getElementUtils();
    typeUtils = processingEnv.getTypeUtils();
  }
 
  @Override
  public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    // This method will be called many times for the source code.
    // Only do something on the first pass.
    pass++;
    if (pass > 1) {
      return true;
    }
 
    messager = processingEnv.getMessager();
 
    List<Element> elements = new ArrayList<>();
    List<Element> excludedElements = new ArrayList<>();
    for (TypeElement te : annotations) {
      if (te.getSimpleName().toString().equals("DesignerComponent")) {
        elements.addAll(roundEnv.getElementsAnnotatedWith(te));
      } else if (te.getSimpleName().toString().equals("SimpleObject")) {
        for (Element element : roundEnv.getElementsAnnotatedWith(te)) {
          SimpleObject annotation = element.getAnnotation(SimpleObject.class);
          if (!annotation.external()) {
            elements.add(element);
          } else {
            excludedElements.add(element);
          }
        }
      }
    }
    for (Element element : elements) {
      processComponent(element);
    }
 
    // Put the component class names (including abstract classes)
    componentTypes.addAll(components.keySet());
    for (Element element : excludedElements) {
      componentTypes.add(element.asType().toString());  // allow extensions to reference one another
    }
 
    // Remove non-components before calling outputResults.
    List<String> removeList = Lists.newArrayList();
    for (Map.Entry<String, ComponentInfo> entry : components.entrySet()) {
      ComponentInfo component = entry.getValue();
      if (component.abstractClass || !component.designerComponent) {
        removeList.add(entry.getKey());
      }
    }
    components.keySet().removeAll(removeList);
 
    try {
      // This is an abstract method implemented in concrete subclasses.
      outputResults();
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
 
    // We need to return false here so that sibling annotation processors can run
    return false;
  }
 
    /*
     * This processes an element if it represents a component, reading in its
     * information and adding it to components.  If this component is a
     * subclass of another component, this method recursively calls itself on the
     * superclass.
     */
  private void processComponent(Element element) {
    boolean isForDesigner = element.getAnnotation(DesignerComponent.class) != null;
    // If the element is not a component (e.g., Float), return early.
    if (element.getAnnotation(SimpleObject.class) == null && !isForDesigner) {
      return;
    }
 
    // If we already processed this component, return early.
    String longComponentName = ((TypeElement) element).getQualifiedName().toString();
    if (components.containsKey(longComponentName)) {
      return;
    }
 
    // Create new ComponentInfo.
    ComponentInfo componentInfo = new ComponentInfo(element);
 
    // Check if this extends another component (DesignerComponent or SimpleObject).
    List<? extends TypeMirror> directSupertypes = typeUtils.directSupertypes(element.asType());
    if (!directSupertypes.isEmpty()) {
      // Only look at the first one.  Later ones would be interfaces,
      // which we don't care about.
      String parentName = directSupertypes.get(0).toString();
      Element e = ((DeclaredType) directSupertypes.get(0)).asElement();
      parentName = ((TypeElement) e).getQualifiedName().toString();
      ComponentInfo parentComponent = components.get(parentName);
      if (parentComponent == null) {
        // Try to process the parent component now.
        Element parentElement = elementUtils.getTypeElement(parentName);
        if (parentElement != null) {
          processComponent(parentElement);
          parentComponent = components.get(parentName);
        }
      }
 
      // If we still can't find the parent class, we don't care about it, since it's not a
      // component (but something like java.lang.Object).  Otherwise, we need to copy its
      // build info, designer properties, properties, methods, and events.
      if (parentComponent != null) {
        // Copy its build info, designer properties, properties, methods, and events.
        componentInfo.permissions.addAll(parentComponent.permissions);
        componentInfo.libraries.addAll(parentComponent.libraries);
        componentInfo.nativeLibraries.addAll(parentComponent.nativeLibraries);
        componentInfo.assets.addAll(parentComponent.assets);
        componentInfo.activities.addAll(parentComponent.activities);
        componentInfo.metadata.addAll(parentComponent.metadata);
        componentInfo.activityMetadata.addAll(parentComponent.activityMetadata);
        componentInfo.broadcastReceivers.addAll(parentComponent.broadcastReceivers);
        componentInfo.services.addAll(parentComponent.services);
        componentInfo.contentProviders.addAll(parentComponent.contentProviders);
        // TODO(Will): Remove the following call once the deprecated
        //             @SimpleBroadcastReceiver annotation is removed. It should
        //             should remain for the time being because otherwise we'll break
        //             extensions currently using @SimpleBroadcastReceiver.
        componentInfo.classNameAndActionsBR.addAll(parentComponent.classNameAndActionsBR);
        // Since we don't modify DesignerProperties, we can just call Map.putAll to copy the
        // designer properties from parentComponent to componentInfo.
        componentInfo.designerProperties.putAll(parentComponent.designerProperties);
        // NOTE(lizlooney) We can't just call Map.putAll to copy the events/properties/methods from
        // parentComponent to componentInfo because then each component will share a single
        // Event/Property/Method and if one component overrides something about an
        // Event/Property/Method, then it will affect all the other components that are sharing
        // that Event/Property/Method.
        for (Map.Entry<String, Event> entry : parentComponent.events.entrySet()) {
          componentInfo.events.put(entry.getKey(), entry.getValue().clone());
        }
        for (Map.Entry<String, Property> entry : parentComponent.properties.entrySet()) {
          componentInfo.properties.put(entry.getKey(), entry.getValue().clone());
        }
        for (Map.Entry<String, Method> entry : parentComponent.methods.entrySet()) {
          componentInfo.methods.put(entry.getKey(), entry.getValue().clone());
        }
      }
    }
 
    // Gather permissions.
    UsesPermissions usesPermissions = element.getAnnotation(UsesPermissions.class);
    if (usesPermissions != null) {
      for (String permission : usesPermissions.permissionNames().split(",")) {
        updateWithNonEmptyValue(componentInfo.permissions, permission);
      }
      Collections.addAll(componentInfo.permissions, usesPermissions.value());
    }
 
    // Gather library names.
    UsesLibraries usesLibraries = element.getAnnotation(UsesLibraries.class);
    if (usesLibraries != null) {
      for (String library : usesLibraries.libraries().split(",")) {
        updateWithNonEmptyValue(componentInfo.libraries, library);
      }
      Collections.addAll(componentInfo.libraries, usesLibraries.value());
    }
 
    // Gather native library names.
    UsesNativeLibraries usesNativeLibraries = element.getAnnotation(UsesNativeLibraries.class);
    if (usesNativeLibraries != null) {
      for (String nativeLibrary : usesNativeLibraries.libraries().split(",")) {
        updateWithNonEmptyValue(componentInfo.nativeLibraries, nativeLibrary);
      }
      for (String v7aLibrary : usesNativeLibraries.v7aLibraries().split(",")) {
        updateWithNonEmptyValue(componentInfo.nativeLibraries, v7aLibrary.trim() + ARMEABI_V7A_SUFFIX);
      }
      for (String v8aLibrary : usesNativeLibraries.v8aLibraries().split(",")) {
        updateWithNonEmptyValue(componentInfo.nativeLibraries, v8aLibrary.trim() + ARM64_V8A_SUFFIX);
      }
      for (String x8664Library : usesNativeLibraries.x86_64Libraries().split(",")) {
        updateWithNonEmptyValue(componentInfo.nativeLibraries, x8664Library.trim() + X86_64_SUFFIX);
      }
 
    }
 
    // Gather required files.
    UsesAssets usesAssets = element.getAnnotation(UsesAssets.class);
    if (usesAssets != null) {
      for (String file : usesAssets.fileNames().split(",")) {
        updateWithNonEmptyValue(componentInfo.assets, file);
      }
    }
 
    // Gather the required activities and build their element strings.
    UsesActivities usesActivities = element.getAnnotation(UsesActivities.class);
    if (usesActivities != null) {
      try {
        for (ActivityElement ae : usesActivities.activities()) {
          updateWithNonEmptyValue(componentInfo.activities, activityElementToString(ae));
        }
      } catch (IllegalAccessException e) {
        messager.printMessage(Diagnostic.Kind.ERROR, "IllegalAccessException when gathering " +
            "activity attributes and subelements for component " + componentInfo.name);
        throw new RuntimeException(e);
      } catch (InvocationTargetException e) {
        messager.printMessage(Diagnostic.Kind.ERROR, "InvocationTargetException when gathering " +
            "activity attributes and subelements for component " + componentInfo.name);
        throw new RuntimeException(e);
      }
    }
 
    // Gather the required metadata and build their element strings.
    UsesApplicationMetadata usesApplicationMetadata = element.getAnnotation(UsesApplicationMetadata.class);
    if (usesApplicationMetadata != null) {
      try {
        for (MetaDataElement me : usesApplicationMetadata.metaDataElements()) {
          updateWithNonEmptyValue(componentInfo.metadata, metaDataElementToString(me));
        }
      } catch (IllegalAccessException e) {
        messager.printMessage(Diagnostic.Kind.ERROR, "IllegalAccessException when gathering " +
            "application metadata and subelements for component " + componentInfo.name);
        throw new RuntimeException(e);
      } catch (InvocationTargetException e) {
        messager.printMessage(Diagnostic.Kind.ERROR, "InvocationTargetException when gathering " +
            "application metadata and subelements for component " + componentInfo.name);
        throw new RuntimeException(e);
      }
    }
 
    // Gather the required activity metadata and build their element strings.
    UsesActivityMetadata usesActivityMetadata = element.getAnnotation(UsesActivityMetadata.class);
    if (usesActivityMetadata != null) {
      try {
        for (MetaDataElement me : usesActivityMetadata.metaDataElements()) {
          updateWithNonEmptyValue(componentInfo.activityMetadata, metaDataElementToString(me));
        }
      } catch (IllegalAccessException e) {
        messager.printMessage(Diagnostic.Kind.ERROR, "IllegalAccessException when gathering " +
                "application metadata and subelements for component " + componentInfo.name);
        throw new RuntimeException(e);
      } catch (InvocationTargetException e) {
        messager.printMessage(Diagnostic.Kind.ERROR, "InvocationTargetException when gathering " +
                "application metadata and subelements for component " + componentInfo.name);
        throw new RuntimeException(e);
      }
    }
 
    // Gather the required broadcast receivers and build their element strings.
    UsesBroadcastReceivers usesBroadcastReceivers = element.getAnnotation(UsesBroadcastReceivers.class);
    if (usesBroadcastReceivers != null) {
      try {
        for (ReceiverElement re : usesBroadcastReceivers.receivers()) {
          updateWithNonEmptyValue(componentInfo.broadcastReceivers, receiverElementToString(re));
        }
      } catch (IllegalAccessException e) {
        messager.printMessage(Diagnostic.Kind.ERROR, "IllegalAccessException when gathering " +
            "broadcast receiver attributes and subelements for component " + componentInfo.name);
        throw new RuntimeException(e);
      } catch (InvocationTargetException e) {
        messager.printMessage(Diagnostic.Kind.ERROR, "InvocationTargetException when gathering " +
            "broadcast receiver attributes and subelements for component " + componentInfo.name);
        throw new RuntimeException(e);
      }
    }
 
    // Gather the required services and build their element strings.
    UsesServices usesServices = element.getAnnotation(UsesServices.class);
    if (usesServices != null) {
      try {
        for (ServiceElement se : usesServices.services()) {
          updateWithNonEmptyValue(componentInfo.services, serviceElementToString(se));
        }
      } catch (IllegalAccessException e) {
        messager.printMessage(Diagnostic.Kind.ERROR, "IllegalAccessException when gathering " +
            "service attributes and subelements for component " + componentInfo.name);
        throw new RuntimeException(e);
      } catch (InvocationTargetException e) {
        messager.printMessage(Diagnostic.Kind.ERROR, "InvocationTargetException when gathering " +
            "service attributes and subelements for component " + componentInfo.name);
        throw new RuntimeException(e);
      }
    }
 
    // Gather the required content providers and build their element strings.
    UsesContentProviders usesContentProviders = element.getAnnotation(UsesContentProviders.class);
    if (usesContentProviders != null) {
      try {
        for (ProviderElement pe : usesContentProviders.providers()) {
          updateWithNonEmptyValue(componentInfo.contentProviders, providerElementToString(pe));
        }
      } catch (IllegalAccessException e) {
        messager.printMessage(Diagnostic.Kind.ERROR, "IllegalAccessException when gathering " +
            "provider attributes and subelements for component " + componentInfo.name);
        throw new RuntimeException(e);
      } catch (InvocationTargetException e) {
        messager.printMessage(Diagnostic.Kind.ERROR, "InvocationTargetException when gathering " +
            "provider attributes and subelements for component " + componentInfo.name);
        throw new RuntimeException(e);
      }
    }
 
    // TODO(Will): Remove the following legacy code once the deprecated
    //             @SimpleBroadcastReceiver annotation is removed. It should
    //             should remain for the time being because otherwise we'll break
    //             extensions currently using @SimpleBroadcastReceiver.
    //
    // Gather required actions for legacy Broadcast Receivers. The annotation
    // has a Class Name and zero or more Filter Actions.  In the
    // resulting String, Class name will go first, and each Action
    // will be added, separated by a comma.
 
    SimpleBroadcastReceiver simpleBroadcastReceiver = element.getAnnotation(SimpleBroadcastReceiver.class);
    if (simpleBroadcastReceiver != null) {
      for (String className : simpleBroadcastReceiver.className().split(",")){
        StringBuffer nameAndActions = new StringBuffer();
        nameAndActions.append(className.trim());
        for (String action : simpleBroadcastReceiver.actions().split(",")) {
          nameAndActions.append("," + action.trim());
        }
        componentInfo.classNameAndActionsBR.add(nameAndActions.toString());
        break; // We only need one class name; If more than one is passed, ignore all but first.
      }
    }
 
    // Build up event information.
    processEvents(componentInfo, element);
 
    // Build up property information.
    processProperties(componentInfo, element);
 
    // Build up method information.
    processMethods(componentInfo, element);
 
    if (isForDesigner) {
      processDescriptions(componentInfo);
    }
 
    // Add it to our components map.
    components.put(longComponentName, componentInfo);
  }
 
  private void processDescriptions(ComponentInfo info) {
    final String name = info.displayName;
    info.description = info.description.replaceAll(TYPE_PLACEHOLDER, name);
    info.helpUrl = info.helpUrl.replaceAll(TYPE_PLACEHOLDER, name);
    for (Property property : info.properties.values()) {
      property.description = property.description.replaceAll(TYPE_PLACEHOLDER, name);
    }
    for (Event event : info.events.values()) {
      event.description = event.description.replaceAll(TYPE_PLACEHOLDER, name);
    }
    for (Method method : info.methods.values()) {
      method.description = method.description.replaceAll(TYPE_PLACEHOLDER, name);
    }
  }
 
  private boolean isPublicMethod(Element element) {
    return element.getModifiers().contains(Modifier.PUBLIC)
        && element.getKind() == ElementKind.METHOD;
  }
 
  private Property executableElementToProperty(Element element, String componentInfoName) {
    String propertyName = element.getSimpleName().toString();
    SimpleProperty simpleProperty = element.getAnnotation(SimpleProperty.class);
 
    if (!(element.asType() instanceof ExecutableType)) {
      throw new RuntimeException("element.asType() is not an ExecutableType for " +
                                 propertyName);
    }
 
    // Use Javadoc for property unless description is set to a non-empty string.
    String description = elementUtils.getDocComment(element);
    String longDescription = description;
    if (!simpleProperty.description().isEmpty()) {
      description = simpleProperty.description();
    }
    if (description == null) {
      description = "";
    }
    // Read only until the first javadoc parameter
    description = description.split("[^\\\\][@{]")[0].trim();
 
    Property property = new Property(propertyName,
                                     description,
                                     longDescription,
                                     simpleProperty.category(),
                                     simpleProperty.userVisible(),
                                     elementUtils.isDeprecated(element));
 
    // Get parameters to tell if this is a getter or setter.
    ExecutableType executableType = (ExecutableType) element.asType();
    List<? extends TypeMirror> parameters = executableType.getParameterTypes();
 
    // Check if it is a setter or getter, and set the property's readable, writable,
    // and type fields appropriately.
    TypeMirror typeMirror;
    if (parameters.size() == 0) {
      // It is a getter.
      property.readable = true;
      typeMirror = executableType.getReturnType();
      if (typeMirror.getKind().equals(TypeKind.VOID)) {
        throw new RuntimeException("Property method is void and has no parameters: "
                                   + propertyName);
      }
      if (element.getAnnotation(IsColor.class) != null) {
        property.color = true;
      }
    } else {
      // It is a setter.
      property.writable = true;
      if (parameters.size() != 1) {
        throw new RuntimeException("Too many parameters for setter for " +
                                   propertyName);
      }
      typeMirror = parameters.get(0);
      for (VariableElement ve : ((ExecutableElement) element).getParameters()) {
        if (ve.getAnnotation(IsColor.class) != null) {
          property.color = true;
        }
      }
    }
 
    // Use typeMirror to set the property's type.
    if (!typeMirror.getKind().equals(TypeKind.VOID)) {
      property.type = typeMirror.toString();
      updateComponentTypes(typeMirror);
    }
 
    property.componentInfoName = componentInfoName;
 
    return property;
  }
 
  // Transform an @ActivityElement into an XML element String for use later
  // in creating AndroidManifest.xml.
  private static String activityElementToString(ActivityElement element)
      throws IllegalAccessException, InvocationTargetException {
    // First, we build the <activity> element's opening tag including any
    // receiver element attributes.
    StringBuilder elementString = new StringBuilder("    <activity ");
    elementString.append(elementAttributesToString(element));
    elementString.append(">\\n");
 
    // Now, we collect any <activity> subelements.
    elementString.append(subelementsToString(element.metaDataElements()));
    elementString.append(subelementsToString(element.intentFilters()));
 
    // Finally, we close the <activity> element and create its String.
    return elementString.append("    </activity>\\n").toString();
  }
 
  // Transform a @ReceiverElement into an XML element String for use later
  // in creating AndroidManifest.xml.
  private static String receiverElementToString(ReceiverElement element)
      throws IllegalAccessException, InvocationTargetException {
    // First, we build the <receiver> element's opening tag including any
    // receiver element attributes.
    StringBuilder elementString = new StringBuilder("    <receiver ");
    elementString.append(elementAttributesToString(element));
    elementString.append(">\\n");
 
    // Now, we collect any <receiver> subelements.
    elementString.append(subelementsToString(element.metaDataElements()));
    elementString.append(subelementsToString(element.intentFilters()));
 
    // Finally, we close the <receiver> element and create its String.
    return elementString.append("    </receiver>\\n").toString();
  }
 
  // Transform a @ServiceElement into an XML element String for use later
  // in creating AndroidManifest.xml.
  private static String serviceElementToString(ServiceElement element)
      throws IllegalAccessException, InvocationTargetException {
    // First, we build the <service> element's opening tag including any
    // service element attributes.
    StringBuilder elementString = new StringBuilder("    <service ");
    elementString.append(elementAttributesToString(element));
    elementString.append(">\\n");
 
    // Now, we collect any <service> subelements.
    elementString.append(subelementsToString(element.metaDataElements()));
    elementString.append(subelementsToString(element.intentFilters()));
 
    // Finally, we close the <service> element and create its String.
    return elementString.append("    </service>\\n").toString();
  }
 
  // Transform a @ProviderElement into an XML element String for use later
  // in creating AndroidManifest.xml.
  private static String providerElementToString(ProviderElement element)
      throws IllegalAccessException, InvocationTargetException {
    // First, we build the <provider> element's opening tag including any
    // content provider element attributes.
    StringBuilder elementString = new StringBuilder("    <provider ");
    elementString.append(elementAttributesToString(element));
    elementString.append(">\\n");
 
    // Now, we collect any <provider> subelements.
    elementString.append(subelementsToString(element.metaDataElements()));
    elementString.append(subelementsToString(element.pathPermissionElement()));
    elementString.append(subelementsToString(element.grantUriPermissionElement()));
 
    // Finally, we close the <provider> element and create its String.
    return elementString.append("    </provider>\\n").toString();
  }
 
  // Transform a @MetaDataElement into an XML element String for use later
  // in creating AndroidManifest.xml.
  private static String metaDataElementToString(MetaDataElement element)
      throws IllegalAccessException, InvocationTargetException {
    // First, we build the <meta-data> element's opening tag including any
    // receiver element attributes.
    StringBuilder elementString = new StringBuilder("      <meta-data ");
    elementString.append(elementAttributesToString(element));
    // Finally, we close the <meta-data> element and create its String.
    return elementString.append("/>\\n").toString();
  }
 
  // Transform an @IntentFilterElement into an XML element String for use later
  // in creating AndroidManifest.xml.
  private static String intentFilterElementToString(IntentFilterElement element)
      throws IllegalAccessException, InvocationTargetException {
    // First, we build the <intent-filter> element's opening tag including any
    // receiver element attributes.
    StringBuilder elementString = new StringBuilder("      <intent-filter ");
    elementString.append(elementAttributesToString(element));
    elementString.append(">\\n");
 
    // Now, we collect any <intent-filter> subelements.
    elementString.append(subelementsToString(element.actionElements()));
    elementString.append(subelementsToString(element.categoryElements()));
    elementString.append(subelementsToString(element.dataElements()));
 
    // Finally, we close the <intent-filter> element and create its String.
    return elementString.append("    </intent-filter>\\n").toString();
  }
 
  // Transform an @ActionElement into an XML element String for use later
  // in creating AndroidManifest.xml.
  private static String actionElementToString(ActionElement element)
      throws IllegalAccessException, InvocationTargetException {
    // First, we build the <action> element's opening tag including any
    // receiver element attributes.
    StringBuilder elementString = new StringBuilder("        <action ");
    elementString.append(elementAttributesToString(element));
    // Finally, we close the <action> element and create its String.
    return elementString.append("/>\\n").toString();
  }
 
  // Transform a @CategoryElement into an XML element String for use later
  // in creating AndroidManifest.xml.
  private static String categoryElementToString(CategoryElement element)
      throws IllegalAccessException, InvocationTargetException {
    // First, we build the <category> element's opening tag including any
    // receiver element attributes.
    StringBuilder elementString = new StringBuilder("        <category ");
    elementString.append(elementAttributesToString(element));
    // Finally, we close the <category> element and create its String.
    return elementString.append("/>\\n").toString();
  }
 
  // Transform a @DataElement into an XML element String for use later
  // in creating AndroidManifest.xml.
  private static String dataElementToString(DataElement element)
      throws IllegalAccessException, InvocationTargetException {
    // First, we build the <data> element's opening tag including any
    // receiver element attributes.
    StringBuilder elementString = new StringBuilder("        <data ");
    elementString.append(elementAttributesToString(element));
    // Finally, we close the <data> element and create its String.
    return elementString.append("/>\\n").toString();
  }
 
  // Transform a @PathPermissionElement into an XML element String for use later
  // in creating AndroidManifest.xml.
  private static String pathPermissionElementToString(PathPermissionElement element)
      throws IllegalAccessException, InvocationTargetException {
    // First, we build the <path-permission> element's opening tag including any
    // receiver element attributes.
    StringBuilder elementString = new StringBuilder("        <path-permission ");
    elementString.append(elementAttributesToString(element));
    // Finally, we close the <path-permission> element and create its String.
    return elementString.append("/>\\n").toString();
  }
 
  // Transform a @GrantUriPermissionElement into an XML element String for use later
  // in creating AndroidManifest.xml.
  private static String grantUriPermissionElementToString(GrantUriPermissionElement element)
      throws IllegalAccessException, InvocationTargetException {
    // First, we build the <grant-uri-permission> element's opening tag including any
    // receiver element attributes.
    StringBuilder elementString = new StringBuilder("        <grant-uri-permission ");
    elementString.append(elementAttributesToString(element));
    // Finally, we close the <grant-uri-permission> element and create its String.
    return elementString.append("/>\\n").toString();
  }
 
  // Build the attribute String for a given XML element modeled by an
  // annotation.
  //
  // Note that we use the fully qualified names for certain classes in the
  // "java.lang.reflect" package to avoid namespace collisions.
  private static String elementAttributesToString(Annotation element)
      throws IllegalAccessException, InvocationTargetException {
    StringBuilder attributeString = new StringBuilder("");
    Class<? extends Annotation> clazz = element.annotationType();
    java.lang.reflect.Method[] methods = clazz.getDeclaredMethods();
    String attributeSeparator = "";
    for (java.lang.reflect.Method method : methods) {
      int modCode = method.getModifiers();
      if (java.lang.reflect.Modifier.isPublic(modCode)
          && !java.lang.reflect.Modifier.isStatic(modCode)) {
        if (method.getReturnType().getSimpleName().equals("String")) {
          // It is an XML element attribute.
          String attributeValue = (String) method.invoke(clazz.cast(element));
          if (!attributeValue.equals("")) {
            attributeString.append(attributeSeparator);
            attributeString.append("android:");
            attributeString.append(method.getName());
            attributeString.append("=\\\"");
            attributeString.append(attributeValue);
            attributeString.append("\\\"");
            attributeSeparator = " ";
          }
        }
      }
    }
    return attributeString.toString();
  }
 
  // Build the subelement String for a given array of XML elements modeled by
  // corresponding annotations.
  private static String subelementsToString(Annotation[] subelements)
      throws IllegalAccessException, InvocationTargetException {
    StringBuilder subelementString = new StringBuilder("");
    for (Annotation subelement : subelements) {
      if (subelement instanceof MetaDataElement) {
        subelementString.append(metaDataElementToString((MetaDataElement) subelement));
      } else if (subelement instanceof IntentFilterElement) {
        subelementString.append(intentFilterElementToString((IntentFilterElement) subelement));
      } else if (subelement instanceof ActionElement) {
        subelementString.append(actionElementToString((ActionElement) subelement));
      } else if (subelement instanceof CategoryElement) {
        subelementString.append(categoryElementToString((CategoryElement) subelement));
      } else if (subelement instanceof DataElement) {
        subelementString.append(dataElementToString((DataElement) subelement));
      } else if (subelement instanceof PathPermissionElement) {
        subelementString.append(pathPermissionElementToString((PathPermissionElement) subelement));
      } else if (subelement instanceof GrantUriPermissionElement) {
        subelementString.append(grantUriPermissionElementToString((GrantUriPermissionElement) subelement));
      }
    }
    return subelementString.toString();
  }
 
  private void processProperties(ComponentInfo componentInfo,
                                 Element componentElement) {
    // We no longer support properties that use the variant type.
 
    Map<String, Element> propertyElementsToCheck = new HashMap<>();
 
    for (Element element : componentElement.getEnclosedElements()) {
      if (!isPublicMethod(element)) {
        continue;
      }
 
      // Get the name of the prospective property.
      String propertyName = element.getSimpleName().toString();
      processConditionalAnnotations(componentInfo, element, propertyName);
 
      // Designer property information
      DesignerProperty designerProperty = element.getAnnotation(DesignerProperty.class);
      if (designerProperty != null) {
        componentInfo.designerProperties.put(propertyName, designerProperty);
        propertyElementsToCheck.put(propertyName, element);
      }
 
      // If property is overridden without again using SimpleProperty, remove
      // it.  For example, this is done for Ball.Width(), which overrides the
      // inherited property Width() because Ball uses Radius() instead.
      if (element.getAnnotation(SimpleProperty.class) == null) {
        if (componentInfo.properties.containsKey(propertyName)) {
          // Look at the prior property's componentInfoName.
          Property priorProperty = componentInfo.properties.get(propertyName);
          if (priorProperty.componentInfoName.equals(componentInfo.name)) {
            // The prior property's componentInfoName is the same as this componentInfo's name.
            // This is just a read-only or write-only property. We don't need to do anything
            // special here.
          } else {
            // The prior property's componentInfoName is the different than this componentInfo's
            // name. This is an overridden property without the SimpleProperty annotation and we
            // need to remove it.
            componentInfo.properties.remove(propertyName);
          }
        }
      } else {
        // Create a new Property element, then compare and combine it with any
        // prior Property element with the same property name, verifying that
        // they are consistent.
        Property newProperty = executableElementToProperty(element, componentInfo.name);
        if (designerProperty != null
            && designerProperty.editorType().equals(PropertyTypeConstants.PROPERTY_TYPE_COLOR)) {
          // Properties that use a color editor should be marked as a color property
          newProperty.color = true;
        }
 
        if (componentInfo.properties.containsKey(propertyName)) {
          Property priorProperty = componentInfo.properties.get(propertyName);
 
          if (!priorProperty.type.equals(newProperty.type)) {
            // The 'real' type of a property is determined by its getter, if
            // it has one.  In theory there can be multiple setters which
            // take different types and those types can differ from the
            // getter.
            if (newProperty.readable) {
              priorProperty.type = newProperty.type;
            } else if (priorProperty.writable) {
              // TODO(user): handle lang_def and document generation for multiple setters.
              throw new RuntimeException("Inconsistent types " + priorProperty.type +
                                         " and " + newProperty.type + " for property " +
                                         propertyName + " in component " + componentInfo.name);
            }
          }
 
          // Merge newProperty into priorProperty, which is already in the properties map.
          if ((priorProperty.description.isEmpty() || priorProperty.isDefaultDescription()
               || element.getAnnotation(Override.class) != null)
              && !newProperty.description.isEmpty() && !newProperty.isDefaultDescription()) {
            priorProperty.setDescription(newProperty.description);
          }
          if (!newProperty.longDescription.isEmpty()) {  /* Latter descriptions of the same property
                                                            override earlier descriptions. */
            priorProperty.longDescription = newProperty.longDescription;
          }
          if (priorProperty.propertyCategory == PropertyCategory.UNSET) {
            priorProperty.propertyCategory = newProperty.propertyCategory;
          } else if (newProperty.propertyCategory != priorProperty.propertyCategory &&
                     newProperty.propertyCategory != PropertyCategory.UNSET) {
            throw new RuntimeException(
                "Property " + propertyName + " has inconsistent categories " +
                priorProperty.propertyCategory + " and " +
                newProperty.propertyCategory + " in component " +
                componentInfo.name);
          }
          priorProperty.readable = priorProperty.readable || newProperty.readable;
          priorProperty.writable = priorProperty.writable || newProperty.writable;
          priorProperty.userVisible = priorProperty.isUserVisible() && newProperty.isUserVisible();
          priorProperty.deprecated = priorProperty.isDeprecated() && newProperty.isDeprecated();
          priorProperty.componentInfoName = componentInfo.name;
          priorProperty.color = newProperty.color || priorProperty.color;
        } else {
          // Add the new property to the properties map.
          componentInfo.properties.put(propertyName, newProperty);
        }
      }
    }
 
    // Verify that every DesignerComponent has a corresponding property entry. A mismatch results
    // in App Inventor being unable to generate code for the designer since the type information
    // is in the block property only. We check that the designer property name is also present
    // in the block properties. If not, an error is reported and the build terminates.
    Set<String> propertyNames = new HashSet<>(componentInfo.designerProperties.keySet());
    propertyNames.removeAll(componentInfo.properties.keySet());
    if (!propertyNames.isEmpty()) {
      for (String propertyName : propertyNames) {
        messager.printMessage(Kind.ERROR,
            String.format(MISSING_SIMPLE_PROPERTY_ANNOTATION, propertyName),
            propertyElementsToCheck.get(propertyName));
      }
    }
  }
 
  // Note: The top halves of the bodies of processEvent() and processMethods()
  // are very similar.  I tried refactoring in several ways but it just made
  // things more complex.
  private void processEvents(ComponentInfo componentInfo,
                             Element componentElement) {
    for (Element element : componentElement.getEnclosedElements()) {
      if (!isPublicMethod(element)) {
        continue;
      }
 
      // Get the name of the prospective event.
      String eventName = element.getSimpleName().toString();
      processConditionalAnnotations(componentInfo, element, eventName);
 
      SimpleEvent simpleEventAnnotation = element.getAnnotation(SimpleEvent.class);
 
      // Remove overriden events unless SimpleEvent is again specified.
      // See comment in processProperties for an example.
      if (simpleEventAnnotation == null) {
        if (componentInfo.events.containsKey(eventName)) {
          componentInfo.events.remove(eventName);
        }
      } else {
        String eventDescription = simpleEventAnnotation.description();
        String longEventDescription = elementUtils.getDocComment(element);
        if (eventDescription.isEmpty()) {
          eventDescription = longEventDescription;
          if (eventDescription == null) {
            messager.printMessage(Diagnostic.Kind.WARNING,
                                  "In component " + componentInfo.name +
                                  ", event " + eventName +
                                  " is missing a description.");
            eventDescription = "";
          }
        }
        boolean userVisible = simpleEventAnnotation.userVisible();
        boolean deprecated = elementUtils.isDeprecated(element);
        Event event = new Event(eventName, eventDescription, longEventDescription, userVisible, deprecated);
        componentInfo.events.put(event.name, event);
 
        // Verify that this element has an ExecutableType.
        if (!(element instanceof ExecutableElement)) {
          throw new RuntimeException("In component " + componentInfo.name +
                                     ", the representation of SimpleEvent " + eventName +
                                     " does not implement ExecutableElement.");
        }
        ExecutableElement e = (ExecutableElement) element;
 
        // Extract the parameters.
        for (VariableElement ve : e.getParameters()) {
          event.addParameter(ve.getSimpleName().toString(),
                             ve.asType().toString(),
                             ve.getAnnotation(IsColor.class) != null);
          updateComponentTypes(ve.asType());
        }
      }
    }
  }
 
  private void processMethods(ComponentInfo componentInfo,
                                Element componentElement) {
    for (Element element : componentElement.getEnclosedElements()) {
      if (!isPublicMethod(element)) {
        continue;
      }
 
      // Get the name of the prospective method.
      String methodName = element.getSimpleName().toString();
      processConditionalAnnotations(componentInfo, element, methodName);
 
      SimpleFunction simpleFunctionAnnotation = element.getAnnotation(SimpleFunction.class);
 
      // Remove overriden methods unless SimpleFunction is again specified.
      // See comment in processProperties for an example.
      if (simpleFunctionAnnotation == null) {
        if (componentInfo.methods.containsKey(methodName)) {
          componentInfo.methods.remove(methodName);
        }
      } else {
        String methodLongDescription = elementUtils.getDocComment(element);
        String methodDescription = simpleFunctionAnnotation.description();
        if (methodDescription.isEmpty()) {
          methodDescription = methodLongDescription;
          if (methodDescription == null) {
            messager.printMessage(Diagnostic.Kind.WARNING,
                                  "In component " + componentInfo.name +
                                  ", method " + methodName +
                                  " is missing a description.");
            methodDescription = "";
          }
        }
        boolean userVisible = simpleFunctionAnnotation.userVisible();
        boolean deprecated = elementUtils.isDeprecated(element);
        Method method = new Method(methodName, methodDescription, methodLongDescription, userVisible, deprecated);
        componentInfo.methods.put(method.name, method);
 
        // Verify that this element has an ExecutableType.
        if (!(element instanceof ExecutableElement)) {
          throw new RuntimeException("In component " + componentInfo.name +
                                     ", the representation of SimpleFunction " + methodName +
                                     " does not implement ExecutableElement.");
        }
        ExecutableElement e = (ExecutableElement) element;
 
        // Extract the parameters.
        for (VariableElement ve : e.getParameters()) {
          method.addParameter(ve.getSimpleName().toString(),
                              ve.asType().toString(),
                              ve.getAnnotation(IsColor.class) != null);
          updateComponentTypes(ve.asType());
        }
 
        // Extract the return type.
        if (e.getReturnType().getKind() != TypeKind.VOID) {
          method.returnType = e.getReturnType().toString();
          if (e.getAnnotation(IsColor.class) != null) {
            method.color = true;
          }
          updateComponentTypes(e.getReturnType());
        }
      }
    }
  }
 
  private void processConditionalAnnotations(ComponentInfo componentInfo, Element element,
                                             String blockName) {
    // Conditional UsesPermissions
    UsesPermissions usesPermissions = element.getAnnotation(UsesPermissions.class);
    if (usesPermissions != null) {
      componentInfo.conditionalPermissions.put(blockName, usesPermissions.value());
    }
 
    UsesBroadcastReceivers broadcastReceiver = element.getAnnotation(UsesBroadcastReceivers.class);
    if (broadcastReceiver != null) {
      try {
        Set<String> receivers = new HashSet<>();
        for (ReceiverElement re : broadcastReceiver.receivers()) {
          updateWithNonEmptyValue(receivers, receiverElementToString(re));
        }
        componentInfo.conditionalBroadcastReceivers.put(blockName, receivers.toArray(new String[0]));
      } catch (Exception e) {
        messager.printMessage(Kind.ERROR, "Unable to process broadcast receiver", element);
      }
    }
 
    UsesServices service = element.getAnnotation(UsesServices.class);
    if (service != null) {
      try {
        Set<String> services = new HashSet<>();
        for (ServiceElement se : service.services()) {
          updateWithNonEmptyValue(services, serviceElementToString(se));
        }
        componentInfo.conditionalServices.put(blockName, services.toArray(new String[0]));
      } catch (Exception e) {
        messager.printMessage(Kind.ERROR, "Unable to process service", element);
      }
    }
 
    UsesContentProviders contentProvider = element.getAnnotation(UsesContentProviders.class);
    if (contentProvider != null) {
      try {
        Set<String> providers = new HashSet<>();
        for (ProviderElement pe : contentProvider.providers()) {
          updateWithNonEmptyValue(providers, providerElementToString(pe));
        }
        componentInfo.conditionalContentProviders.put(blockName, providers.toArray(new String[0]));
      } catch (Exception e) {
        messager.printMessage(Kind.ERROR, "Unable to process content provider", element);
      }
    }
  }
 
  protected abstract void outputResults() throws IOException;
 
  protected final String javaTypeToYailType(String type) {
    if (BOXED_TYPES.containsKey(type)) {
      throw new IllegalArgumentException(String.format(BOXED_TYPE_ERROR, type,
          BOXED_TYPES.get(type)));
    }
    // boolean -> boolean
    if (type.equals("boolean")) {
      return type;
    }
    // String -> text
    if (type.equals("java.lang.String")) {
      return "text";
    }
    // {float, double, int, short, long, byte} -> number
    if (type.equals("float") || type.equals("double") || type.equals("int") ||
        type.equals("short") || type.equals("long") || type.equals("byte")) {
      return "number";
    }
    // YailList -> list
    if (type.equals("com.google.appinventor.components.runtime.util.YailList")) {
      return "list";
    }
    // List<?> -> list
    if (type.startsWith("java.util.List")) {
      return "list";
    }
    if (type.equals("com.google.appinventor.components.runtime.util.YailDictionary")) {
      return "dictionary";
    }
    if (type.equals("com.google.appinventor.components.runtime.util.YailObject")) {
      return "yailobject";
    }
 
    // Calendar -> InstantInTime
    if (type.equals("java.util.Calendar")) {
      return "InstantInTime";
    }
 
    if (type.equals("java.lang.Object")) {
      return "any";
    }
 
    if (type.equals("com.google.appinventor.components.runtime.Component")) {
      return "component";
    }
 
    // Check if it's a component.
    if (componentTypes.contains(type)) {
      return "component";
    }
 
    throw new IllegalArgumentException("Cannot convert Java type '" + type + "' to Yail type");
  }
 
  protected FileObject createOutputFileObject(String fileName) throws IOException {
    return processingEnv.getFiler().
      createResource(StandardLocation.SOURCE_OUTPUT, OUTPUT_PACKAGE, fileName);
  }
 
  protected Writer getOutputWriter(String fileName) throws IOException {
    return createOutputFileObject(fileName).openWriter();
  }
 
  private void updateComponentTypes(TypeMirror type) {
    if (type.getKind() == TypeKind.DECLARED) {
      type.accept(new SimpleTypeVisitor7<Boolean, Set<String>>(false) {
        @Override
        public Boolean visitDeclared(DeclaredType t, Set<String> types) {
          final String typeName = t.asElement().toString();
          if ("com.google.appinventor.components.runtime.Component".equals(typeName)) {
            return true;
          }
          if (!types.contains(typeName)) {
            types.add(typeName);
            final TypeElement typeElement = (TypeElement) t.asElement();
            if (typeElement.getSuperclass().accept(this, types)) {
              componentTypes.add(typeName);
              return true;
            }
            for (TypeMirror iface : typeElement.getInterfaces()) {
              if (iface.accept(this, types)) {
                componentTypes.add(typeName);
                return true;
              }
            }
          }
          return componentTypes.contains(typeName);
        }
      }, visitedTypes);
    }
  }
 
  private void updateWithNonEmptyValue(Set<String> collection, String value) {
    String trimmedValue = value.trim();
    if (!trimmedValue.isEmpty()) {
      collection.add(trimmedValue);
    }
  }
}