| /* |
| * Copyright (C) 2011 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.checks; |
| |
| import static com.android.SdkConstants.ANDROID_URI; |
| import static com.android.SdkConstants.ATTR_NAME; |
| import static com.android.SdkConstants.ATTR_REF_PREFIX; |
| import static com.android.SdkConstants.ATTR_TYPE; |
| import static com.android.SdkConstants.DOT_XML; |
| import static com.android.SdkConstants.RESOURCE_CLR_STYLEABLE; |
| import static com.android.SdkConstants.RESOURCE_CLZ_ARRAY; |
| import static com.android.SdkConstants.RESOURCE_CLZ_ID; |
| import static com.android.SdkConstants.R_ATTR_PREFIX; |
| import static com.android.SdkConstants.R_CLASS; |
| import static com.android.SdkConstants.R_ID_PREFIX; |
| import static com.android.SdkConstants.R_PREFIX; |
| import static com.android.SdkConstants.TAG_ARRAY; |
| import static com.android.SdkConstants.TAG_INTEGER_ARRAY; |
| import static com.android.SdkConstants.TAG_ITEM; |
| import static com.android.SdkConstants.TAG_PLURALS; |
| import static com.android.SdkConstants.TAG_RESOURCES; |
| import static com.android.SdkConstants.TAG_STRING_ARRAY; |
| import static com.android.SdkConstants.TAG_STYLE; |
| import static com.android.utils.SdkUtils.getResourceFieldName; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.resources.ResourceType; |
| import com.android.tools.lint.detector.api.Category; |
| import com.android.tools.lint.detector.api.Context; |
| import com.android.tools.lint.detector.api.Detector; |
| import com.android.tools.lint.detector.api.Implementation; |
| import com.android.tools.lint.detector.api.Issue; |
| import com.android.tools.lint.detector.api.JavaContext; |
| import com.android.tools.lint.detector.api.LintUtils; |
| import com.android.tools.lint.detector.api.Location; |
| import com.android.tools.lint.detector.api.Project; |
| import com.android.tools.lint.detector.api.ResourceXmlDetector; |
| import com.android.tools.lint.detector.api.Scope; |
| import com.android.tools.lint.detector.api.Severity; |
| import com.android.tools.lint.detector.api.Speed; |
| import com.android.tools.lint.detector.api.XmlContext; |
| import com.google.common.collect.Lists; |
| |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.EnumSet; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import lombok.ast.AstVisitor; |
| import lombok.ast.ClassDeclaration; |
| import lombok.ast.ForwardingAstVisitor; |
| import lombok.ast.NormalTypeBody; |
| import lombok.ast.VariableDeclaration; |
| import lombok.ast.VariableDefinition; |
| |
| /** |
| * Finds unused resources. |
| * <p> |
| * Note: This detector currently performs *string* analysis to check Java files. |
| * The Lint API needs an official Java AST API (or map to an existing one like |
| * BCEL for bytecode analysis etc) and once it does this should be updated to |
| * use it. |
| */ |
| public class UnusedResourceDetector extends ResourceXmlDetector implements Detector.JavaScanner { |
| |
| private static final Implementation IMPLEMENTATION = new Implementation( |
| UnusedResourceDetector.class, |
| EnumSet.of(Scope.MANIFEST, Scope.ALL_RESOURCE_FILES, Scope.ALL_JAVA_FILES, |
| Scope.TEST_SOURCES)); |
| |
| /** Unused resources (other than ids). */ |
| public static final Issue ISSUE = Issue.create( |
| "UnusedResources", //$NON-NLS-1$ |
| "Unused resources", |
| "Unused resources make applications larger and slow down builds.", |
| Category.PERFORMANCE, |
| 3, |
| Severity.WARNING, |
| IMPLEMENTATION); |
| |
| /** Unused id's */ |
| public static final Issue ISSUE_IDS = Issue.create( |
| "UnusedIds", //$NON-NLS-1$ |
| "Unused id", |
| "This resource id definition appears not to be needed since it is not referenced " + |
| "from anywhere. Having id definitions, even if unused, is not necessarily a bad " + |
| "idea since they make working on layouts and menus easier, so there is not a " + |
| "strong reason to delete these.", |
| Category.PERFORMANCE, |
| 1, |
| Severity.WARNING, |
| IMPLEMENTATION) |
| .setEnabledByDefault(false); |
| |
| private Set<String> mDeclarations; |
| private Set<String> mReferences; |
| private Map<String, Location> mUnused; |
| |
| /** |
| * Constructs a new {@link UnusedResourceDetector} |
| */ |
| public UnusedResourceDetector() { |
| } |
| |
| @Override |
| public void run(@NonNull Context context) { |
| assert false; |
| } |
| |
| @Override |
| public boolean appliesTo(@NonNull Context context, @NonNull File file) { |
| return true; |
| } |
| |
| @Override |
| public void beforeCheckProject(@NonNull Context context) { |
| if (context.getPhase() == 1) { |
| mDeclarations = new HashSet<String>(300); |
| mReferences = new HashSet<String>(300); |
| } |
| } |
| |
| // ---- Implements JavaScanner ---- |
| |
| @Override |
| public void beforeCheckFile(@NonNull Context context) { |
| File file = context.file; |
| |
| boolean isXmlFile = LintUtils.isXmlFile(file); |
| if (isXmlFile || LintUtils.isBitmapFile(file)) { |
| String fileName = file.getName(); |
| String parentName = file.getParentFile().getName(); |
| int dash = parentName.indexOf('-'); |
| String typeName = parentName.substring(0, dash == -1 ? parentName.length() : dash); |
| ResourceType type = ResourceType.getEnum(typeName); |
| if (type != null && LintUtils.isFileBasedResourceType(type)) { |
| String baseName = fileName.substring(0, fileName.length() - DOT_XML.length()); |
| String resource = R_PREFIX + typeName + '.' + baseName; |
| if (context.getPhase() == 1) { |
| mDeclarations.add(resource); |
| } else { |
| assert context.getPhase() == 2; |
| if (mUnused.containsKey(resource)) { |
| // Check whether this is an XML document that has a tools:ignore attribute |
| // on the document element: if so don't record it as a declaration. |
| if (isXmlFile && context instanceof XmlContext) { |
| XmlContext xmlContext = (XmlContext) context; |
| if (xmlContext.document != null |
| && xmlContext.document.getDocumentElement() != null) { |
| Element root = xmlContext.document.getDocumentElement(); |
| if (xmlContext.getDriver().isSuppressed(xmlContext, ISSUE, root)) { |
| // Also remove it from consideration such that even the |
| // presence of this field in the R file is ignored. |
| mUnused.remove(resource); |
| return; |
| } |
| } |
| } |
| |
| if (!context.getProject().getReportIssues()) { |
| // If this is a library project not being analyzed, ignore it |
| mUnused.remove(resource); |
| return; |
| } |
| |
| recordLocation(resource, Location.create(file)); |
| } |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void afterCheckProject(@NonNull Context context) { |
| if (context.getPhase() == 1) { |
| mDeclarations.removeAll(mReferences); |
| Set<String> unused = mDeclarations; |
| mReferences = null; |
| mDeclarations = null; |
| |
| // Remove styles and attributes: they may be used, analysis isn't complete for these |
| List<String> styles = new ArrayList<String>(); |
| for (String resource : unused) { |
| // R.style.x, R.styleable.x, R.attr |
| if (resource.startsWith("R.style") //$NON-NLS-1$ |
| || resource.startsWith("R.attr")) { //$NON-NLS-1$ |
| styles.add(resource); |
| } |
| } |
| unused.removeAll(styles); |
| |
| // Remove id's if the user has disabled reporting issue ids |
| if (!unused.isEmpty() && !context.isEnabled(ISSUE_IDS)) { |
| // Remove all R.id references |
| List<String> ids = new ArrayList<String>(); |
| for (String resource : unused) { |
| if (resource.startsWith(R_ID_PREFIX)) { |
| ids.add(resource); |
| } |
| } |
| unused.removeAll(ids); |
| } |
| |
| if (!unused.isEmpty() && !context.getDriver().hasParserErrors()) { |
| mUnused = new HashMap<String, Location>(unused.size()); |
| for (String resource : unused) { |
| mUnused.put(resource, null); |
| } |
| |
| // Request another pass, and in the second pass we'll gather location |
| // information for all declaration locations we've found |
| context.requestRepeat(this, Scope.ALL_RESOURCES_SCOPE); |
| } |
| } else { |
| assert context.getPhase() == 2; |
| |
| // Report any resources that we (for some reason) could not find a declaration |
| // location for |
| if (!mUnused.isEmpty()) { |
| // Fill in locations for files that we didn't encounter in other ways |
| for (Map.Entry<String, Location> entry : mUnused.entrySet()) { |
| String resource = entry.getKey(); |
| Location location = entry.getValue(); |
| //noinspection VariableNotUsedInsideIf |
| if (location != null) { |
| continue; |
| } |
| |
| // Try to figure out the file if it's a file based resource (such as R.layout) -- |
| // in that case we can figure out the filename since it has a simple mapping |
| // from the resource name (though the presence of qualifiers like -land etc |
| // makes it a little tricky if there's no base file provided) |
| int secondDot = resource.indexOf('.', 2); |
| String typeName = resource.substring(2, secondDot); // 2: Skip R. |
| ResourceType type = ResourceType.getEnum(typeName); |
| if (type != null && LintUtils.isFileBasedResourceType(type)) { |
| String name = resource.substring(secondDot + 1); |
| |
| List<File> folders = Lists.newArrayList(); |
| List<File> resourceFolders = context.getProject().getResourceFolders(); |
| for (File res : resourceFolders) { |
| File[] f = res.listFiles(); |
| if (f != null) { |
| folders.addAll(Arrays.asList(f)); |
| } |
| } |
| if (folders != null) { |
| // Process folders in alphabetical order such that we process |
| // based folders first: we want the locations in base folder |
| // order |
| Collections.sort(folders, new Comparator<File>() { |
| @Override |
| public int compare(File file1, File file2) { |
| return file1.getName().compareTo(file2.getName()); |
| } |
| }); |
| for (File folder : folders) { |
| if (folder.getName().startsWith(typeName)) { |
| File[] files = folder.listFiles(); |
| if (files != null) { |
| Arrays.sort(files); |
| for (File file : files) { |
| String fileName = file.getName(); |
| if (fileName.startsWith(name) |
| && fileName.startsWith(".", //$NON-NLS-1$ |
| name.length())) { |
| recordLocation(resource, Location.create(file)); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| List<String> sorted = new ArrayList<String>(mUnused.keySet()); |
| Collections.sort(sorted); |
| |
| Boolean skippedLibraries = null; |
| |
| for (String resource : sorted) { |
| Location location = mUnused.get(resource); |
| if (location != null) { |
| // We were prepending locations, but we want to prefer the base folders |
| location = Location.reverse(location); |
| } |
| |
| if (location == null) { |
| if (skippedLibraries == null) { |
| skippedLibraries = false; |
| for (Project project : context.getDriver().getProjects()) { |
| if (!project.getReportIssues()) { |
| skippedLibraries = true; |
| break; |
| } |
| } |
| } |
| if (skippedLibraries) { |
| // Skip this resource if we don't have a location, and one or |
| // more library projects were skipped; the resource was very |
| // probably defined in that library project and only encountered |
| // in the main project's java R file |
| continue; |
| } |
| } |
| |
| String message = String.format("The resource `%1$s` appears to be unused", |
| resource); |
| Issue issue = getIssue(resource); |
| // TODO: Compute applicable node scope |
| context.report(issue, location, message); |
| } |
| } |
| } |
| } |
| |
| private static Issue getIssue(String resource) { |
| return resource.startsWith(R_ID_PREFIX) ? ISSUE_IDS : ISSUE; |
| } |
| |
| private void recordLocation(String resource, Location location) { |
| Location oldLocation = mUnused.get(resource); |
| if (oldLocation != null) { |
| location.setSecondary(oldLocation); |
| } |
| mUnused.put(resource, location); |
| } |
| |
| @Override |
| public Collection<String> getApplicableAttributes() { |
| return ALL; |
| } |
| |
| @Override |
| public Collection<String> getApplicableElements() { |
| return Arrays.asList( |
| TAG_STYLE, |
| TAG_RESOURCES, |
| TAG_ARRAY, |
| TAG_STRING_ARRAY, |
| TAG_INTEGER_ARRAY, |
| TAG_PLURALS |
| ); |
| } |
| |
| @Override |
| public void visitElement(@NonNull XmlContext context, @NonNull Element element) { |
| if (TAG_RESOURCES.equals(element.getTagName())) { |
| for (Element item : LintUtils.getChildren(element)) { |
| Attr nameAttribute = item.getAttributeNode(ATTR_NAME); |
| if (nameAttribute != null) { |
| String name = getResourceFieldName(nameAttribute.getValue()); |
| String type = item.getTagName(); |
| if (type.equals(TAG_ITEM)) { |
| type = item.getAttribute(ATTR_TYPE); |
| if (type == null || type.isEmpty()) { |
| type = RESOURCE_CLZ_ID; |
| } |
| } else if (type.equals("declare-styleable")) { //$NON-NLS-1$ |
| type = RESOURCE_CLR_STYLEABLE; |
| } else if (type.contains("array")) { //$NON-NLS-1$ |
| // <string-array> etc |
| type = RESOURCE_CLZ_ARRAY; |
| } |
| String resource = R_PREFIX + type + '.' + name; |
| |
| if (context.getPhase() == 1) { |
| mDeclarations.add(resource); |
| checkChildRefs(item); |
| } else { |
| assert context.getPhase() == 2; |
| if (mUnused.containsKey(resource)) { |
| if (context.getDriver().isSuppressed(context, getIssue(resource), |
| item)) { |
| mUnused.remove(resource); |
| continue; |
| } |
| if (!context.getProject().getReportIssues()) { |
| mUnused.remove(resource); |
| continue; |
| } |
| if (isAnalyticsFile(context)) { |
| mUnused.remove(resource); |
| continue; |
| } |
| |
| recordLocation(resource, context.getLocation(nameAttribute)); |
| } |
| } |
| } |
| } |
| } else //noinspection VariableNotUsedInsideIf |
| if (mReferences != null) { |
| assert TAG_STYLE.equals(element.getTagName()) |
| || TAG_ARRAY.equals(element.getTagName()) |
| || TAG_PLURALS.equals(element.getTagName()) |
| || TAG_INTEGER_ARRAY.equals(element.getTagName()) |
| || TAG_STRING_ARRAY.equals(element.getTagName()); |
| for (Element item : LintUtils.getChildren(element)) { |
| checkChildRefs(item); |
| } |
| } |
| } |
| |
| private static final String ANALYTICS_FILE = "analytics.xml"; //$NON-NLS-1$ |
| |
| /** |
| * Returns true if this XML file corresponds to an Analytics configuration file; |
| * these contain some attributes read by the library which won't be flagged as |
| * used by the application |
| * |
| * @param context the context used for scanning |
| * @return true if the file represents an analytics file |
| */ |
| public static boolean isAnalyticsFile(Context context) { |
| File file = context.file; |
| return file.getPath().endsWith(ANALYTICS_FILE) && file.getName().equals(ANALYTICS_FILE); |
| } |
| |
| private void checkChildRefs(Element item) { |
| // Look for ?attr/ and @dimen/foo etc references in the item children |
| NodeList childNodes = item.getChildNodes(); |
| for (int i = 0, n = childNodes.getLength(); i < n; i++) { |
| Node child = childNodes.item(i); |
| if (child.getNodeType() == Node.TEXT_NODE) { |
| String text = child.getNodeValue(); |
| |
| int index = text.indexOf(ATTR_REF_PREFIX); |
| if (index != -1) { |
| String name = text.substring(index + ATTR_REF_PREFIX.length()).trim(); |
| mReferences.add(R_ATTR_PREFIX + name); |
| } else { |
| index = text.indexOf('@'); |
| if (index != -1 && text.indexOf('/', index) != -1 |
| && !text.startsWith("@android:", index)) { //$NON-NLS-1$ |
| // Compute R-string, e.g. @string/foo => R.string.foo |
| String token = text.substring(index + 1).trim().replace('/', '.'); |
| String r = R_PREFIX + token; |
| mReferences.add(r); |
| } |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void visitAttribute(@NonNull XmlContext context, @NonNull Attr attribute) { |
| String value = attribute.getValue(); |
| |
| if (value.startsWith("@+") && !value.startsWith("@+android")) { //$NON-NLS-1$ //$NON-NLS-2$ |
| String resource = R_PREFIX + value.substring(2).replace('/', '.'); |
| // We already have the declarations when we scan the R file, but we're tracking |
| // these here to get attributes for position info |
| |
| if (context.getPhase() == 1) { |
| mDeclarations.add(resource); |
| } else if (mUnused.containsKey(resource)) { |
| if (context.getDriver().isSuppressed(context, getIssue(resource), attribute)) { |
| mUnused.remove(resource); |
| return; |
| } |
| if (!context.getProject().getReportIssues()) { |
| mUnused.remove(resource); |
| return; |
| } |
| recordLocation(resource, context.getLocation(attribute)); |
| return; |
| } |
| } else if (mReferences != null) { |
| if (value.startsWith("@") //$NON-NLS-1$ |
| && !value.startsWith("@android:")) { //$NON-NLS-1$ |
| // Compute R-string, e.g. @string/foo => R.string.foo |
| String r = R_PREFIX + value.substring(1).replace('/', '.'); |
| mReferences.add(r); |
| } else if (value.startsWith(ATTR_REF_PREFIX)) { |
| mReferences.add(R_ATTR_PREFIX + value.substring(ATTR_REF_PREFIX.length())); |
| } |
| } |
| |
| if (attribute.getNamespaceURI() != null |
| && !ANDROID_URI.equals(attribute.getNamespaceURI()) && mReferences != null) { |
| mReferences.add(R_ATTR_PREFIX + attribute.getLocalName()); |
| } |
| } |
| |
| @NonNull |
| @Override |
| public Speed getSpeed() { |
| return Speed.SLOW; |
| } |
| |
| @Override |
| public List<Class<? extends lombok.ast.Node>> getApplicableNodeTypes() { |
| return Collections.<Class<? extends lombok.ast.Node>>singletonList(ClassDeclaration.class); |
| } |
| |
| @Override |
| public boolean appliesToResourceRefs() { |
| return true; |
| } |
| |
| @Override |
| public void visitResourceReference(@NonNull JavaContext context, @Nullable AstVisitor visitor, |
| @NonNull lombok.ast.Node node, @NonNull String type, @NonNull String name, |
| boolean isFramework) { |
| if (mReferences != null && !isFramework) { |
| String reference = R_PREFIX + type + '.' + name; |
| mReferences.add(reference); |
| } |
| } |
| |
| @Override |
| public AstVisitor createJavaVisitor(@NonNull JavaContext context) { |
| if (mReferences != null) { |
| return new UnusedResourceVisitor(); |
| } else { |
| // Second pass, computing resource declaration locations: No need to look at Java |
| return null; |
| } |
| } |
| |
| // Look for references and declarations |
| private class UnusedResourceVisitor extends ForwardingAstVisitor { |
| @Override |
| public boolean visitClassDeclaration(ClassDeclaration node) { |
| // Look for declarations of R class fields and store them in |
| // mDeclarations |
| String description = node.astName().astValue(); |
| if (description.equals(R_CLASS)) { |
| // This is an R class. We can process this class very deliberately. |
| // The R class has a very specific AST format: |
| // ClassDeclaration ("R") |
| // NormalTypeBody |
| // ClassDeclaration (e.g. "drawable") |
| // NormalTypeBody |
| // VariableDeclaration |
| // VariableDefinition (e.g. "ic_launcher") |
| for (lombok.ast.Node body : node.getChildren()) { |
| if (body instanceof NormalTypeBody) { |
| for (lombok.ast.Node subclass : body.getChildren()) { |
| if (subclass instanceof ClassDeclaration) { |
| String className = ((ClassDeclaration) subclass).astName().astValue(); |
| for (lombok.ast.Node innerBody : subclass.getChildren()) { |
| if (innerBody instanceof NormalTypeBody) { |
| for (lombok.ast.Node field : innerBody.getChildren()) { |
| if (field instanceof VariableDeclaration) { |
| for (lombok.ast.Node child : field.getChildren()) { |
| if (child instanceof VariableDefinition) { |
| VariableDefinition def = |
| (VariableDefinition) child; |
| String name = def.astVariables().first() |
| .astName().astValue(); |
| String resource = R_PREFIX + className |
| + '.' + name; |
| mDeclarations.add(resource); |
| } // Else: It could be a comment node |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| return false; |
| } |
| } |
| } |
