Java tutorial
/* * 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.klint.client.api; import com.android.annotations.NonNull; import com.android.annotations.Nullable; import com.android.ide.common.res2.AbstractResourceRepository; import com.android.ide.common.res2.ResourceItem; import com.android.resources.ResourceFolderType; import com.android.sdklib.IAndroidTarget; import com.android.sdklib.repository.local.LocalSdk; import com.android.tools.klint.detector.api.ClassContext; import com.android.tools.klint.detector.api.Context; import com.android.tools.klint.detector.api.Detector; import com.android.tools.klint.detector.api.Issue; import com.android.tools.klint.detector.api.JavaContext; import com.android.tools.klint.detector.api.LintUtils; import com.android.tools.klint.detector.api.Location; import com.android.tools.klint.detector.api.Project; import com.android.tools.klint.detector.api.ResourceContext; import com.android.tools.klint.detector.api.ResourceXmlDetector; import com.android.tools.klint.detector.api.Scope; import com.android.tools.klint.detector.api.Severity; import com.android.tools.klint.detector.api.TextFormat; import com.android.tools.klint.detector.api.XmlContext; import com.google.common.annotations.Beta; import com.google.common.base.Objects; import com.google.common.collect.*; import com.sun.istack.internal.NotNull; import org.jetbrains.uast.*; import org.jetbrains.uast.check.UastChecker; import org.jetbrains.uast.check.UastScanner; import org.jetbrains.uast.visitor.UastVisitor; import org.objectweb.asm.ClassReader; import org.objectweb.asm.Opcodes; import org.objectweb.asm.tree.*; import org.w3c.dom.Attr; import org.w3c.dom.Element; import java.io.File; import java.io.IOException; import java.net.URL; import java.net.URLConnection; import java.util.*; import java.util.regex.Matcher; import java.util.regex.Pattern; import static com.android.SdkConstants.*; import static com.android.ide.common.resources.configuration.FolderConfiguration.QUALIFIER_SPLITTER; import static java.io.File.separator; /** * Analyzes Android projects and files * <p> * <b>NOTE: This is not a public or final API; if you rely on this be prepared * to adjust your code for the next tools release.</b> */ @Beta public class LintDriver { /** * Max number of passes to run through the lint runner if requested by * {@link #requestRepeat} */ private static final int MAX_PHASES = 3; private static final String SUPPRESS_LINT_VMSIG = '/' + SUPPRESS_LINT + ';'; /** Prefix used by the comment suppress mechanism in Studio/IntelliJ */ private static final String STUDIO_ID_PREFIX = "AndroidLint"; private final LintClient mClient; private LintRequest mRequest; private IssueRegistry mRegistry; private volatile boolean mCanceled; private EnumSet<Scope> mScope; private List<? extends Detector> mApplicableDetectors; private Map<Scope, List<Detector>> mScopeDetectors; private List<LintListener> mListeners; private int mPhase; private List<Detector> mRepeatingDetectors; private EnumSet<Scope> mRepeatScope; private Project[] mCurrentProjects; private Project mCurrentProject; private boolean mAbbreviating = true; private boolean mParserErrors; private Map<Object, Object> mProperties; /** * Creates a new {@link LintDriver} * * @param registry The registry containing issues to be checked * @param client the tool wrapping the analyzer, such as an IDE or a CLI */ public LintDriver(@NonNull IssueRegistry registry, @NonNull LintClient client) { mRegistry = registry; mClient = new LintClientWrapper(client); } /** Cancels the current lint run as soon as possible */ public void cancel() { mCanceled = true; } /** * Returns the scope for the lint job * * @return the scope, never null */ @NonNull public EnumSet<Scope> getScope() { return mScope; } /** * Sets the scope for the lint job * * @param scope the scope to use */ public void setScope(@NonNull EnumSet<Scope> scope) { mScope = scope; } /** * Returns the lint client requesting the lint check. This may not be the same * instance as the one passed in to this driver; lint uses a wrapper which performs * additional validation to ensure that for example badly behaved detectors which report * issues that have been disabled will get muted without the real lint client getting * notified. Thus, this {@link LintClient} is suitable for use by detectors to look * up a client to for example get location handles from, but tool handling code should * never try to cast this client back to their original lint client. For the original * lint client, use {@link LintRequest} instead. * * @return the client, never null */ @NonNull public LintClient getClient() { return mClient; } /** * Returns the current request, which points to the original files to be checked, * the original scope, the original {@link LintClient}, as well as the release mode. * * @return the request */ @NonNull public LintRequest getRequest() { return mRequest; } /** * Records a property for later retrieval by {@link #getProperty(Object)} * * @param key the key to associate the value with * @param value the value, or null to remove a previous binding */ public void putProperty(@NonNull Object key, @Nullable Object value) { if (mProperties == null) { mProperties = Maps.newHashMap(); } if (value == null) { mProperties.remove(key); } else { mProperties.put(key, value); } } /** * Returns the property previously stored with the given key, or null * * @param key the key * @return the value or null if not found */ @Nullable public Object getProperty(@NonNull Object key) { if (mProperties != null) { return mProperties.get(key); } return null; } /** * Returns the current phase number. The first pass is numbered 1. Only one pass * will be performed, unless a {@link Detector} calls {@link #requestRepeat}. * * @return the current phase, usually 1 */ public int getPhase() { return mPhase; } /** * Returns the current {@link IssueRegistry}. * * @return the current {@link IssueRegistry} */ @NonNull public IssueRegistry getRegistry() { return mRegistry; } /** * Returns the project containing a given file, or null if not found. This searches * only among the currently checked project and its library projects, not among all * possible projects being scanned sequentially. * * @param file the file to be checked * @return the corresponding project, or null if not found */ @Nullable public Project findProjectFor(@NonNull File file) { if (mCurrentProjects != null) { if (mCurrentProjects.length == 1) { return mCurrentProjects[0]; } String path = file.getPath(); for (Project project : mCurrentProjects) { if (path.startsWith(project.getDir().getPath())) { return project; } } } return null; } /** * Sets whether lint should abbreviate output when appropriate. * * @param abbreviating true to abbreviate output, false to include everything */ public void setAbbreviating(boolean abbreviating) { mAbbreviating = abbreviating; } /** * Returns whether lint should abbreviate output when appropriate. * * @return true if lint should abbreviate output, false when including everything */ public boolean isAbbreviating() { return mAbbreviating; } /** * Returns whether lint has encountered any files with fatal parser errors * (e.g. broken source code, or even broken parsers) * <p> * This is useful for checks that need to make sure they've seen all data in * order to be conclusive (such as an unused resource check). * * @return true if any files were not properly processed because they * contained parser errors */ public boolean hasParserErrors() { return mParserErrors; } /** * Sets whether lint has encountered files with fatal parser errors. * * @see #hasParserErrors() * @param hasErrors whether parser errors have been encountered */ public void setHasParserErrors(boolean hasErrors) { mParserErrors = hasErrors; } /** * Returns the projects being analyzed * * @return the projects being analyzed */ @NonNull public List<Project> getProjects() { if (mCurrentProjects != null) { return Arrays.asList(mCurrentProjects); } return Collections.emptyList(); } /** * Analyze the given file (which can point to an Android project). Issues found * are reported to the associated {@link LintClient}. * * @param files the files and directories to be analyzed * @param scope the scope of the analysis; detectors with a wider scope will * not be run. If null, the scope will be inferred from the files. * @deprecated use {@link #analyze(LintRequest) instead} */ @Deprecated public void analyze(@NonNull List<File> files, @Nullable EnumSet<Scope> scope) { analyze(new LintRequest(mClient, files).setScope(scope)); } /** * Analyze the given files (which can point to Android projects or directories * containing Android projects). Issues found are reported to the associated * {@link LintClient}. * <p> * Note that the {@link LintDriver} is not multi thread safe or re-entrant; * if you want to run potentially overlapping lint jobs, create a separate driver * for each job. * * @param request the files and directories to be analyzed */ public void analyze(@NonNull LintRequest request) { try { mRequest = request; analyze(); } finally { mRequest = null; } } /** Runs the driver to analyze the requested files */ private void analyze() { mCanceled = false; mScope = mRequest.getScope(); assert mScope == null || !mScope.contains(Scope.ALL_RESOURCE_FILES) || mScope.contains(Scope.RESOURCE_FILE); Collection<Project> projects; try { projects = mRequest.getProjects(); if (projects == null) { projects = computeProjects(mRequest.getFiles()); } } catch (CircularDependencyException e) { mCurrentProject = e.getProject(); if (mCurrentProject != null) { Location location = e.getLocation(); File file = location != null ? location.getFile() : mCurrentProject.getDir(); Context context = new Context(this, mCurrentProject, null, file); context.report(IssueRegistry.LINT_ERROR, e.getLocation(), e.getMessage()); mCurrentProject = null; } return; } if (projects.isEmpty()) { mClient.log(null, "No projects found for %1$s", mRequest.getFiles().toString()); return; } if (mCanceled) { return; } registerCustomRules(projects); if (mScope == null) { mScope = Scope.infer(projects); } fireEvent(LintListener.EventType.STARTING, null); for (Project project : projects) { mPhase = 1; Project main = mRequest.getMainProject(project); // The set of available detectors varies between projects computeDetectors(project); if (mApplicableDetectors.isEmpty()) { // No detectors enabled in this project: skip it continue; } checkProject(project, main); if (mCanceled) { break; } runExtraPhases(project, main); } fireEvent(mCanceled ? LintListener.EventType.CANCELED : LintListener.EventType.COMPLETED, null); } private void registerCustomRules(Collection<Project> projects) { // Look at the various projects, and if any of them provide a custom // lint jar, "add" them (this will replace the issue registry with // a CompositeIssueRegistry containing the original issue registry // plus JarFileIssueRegistry instances for each lint jar Set<File> jarFiles = Sets.newHashSet(); for (Project project : projects) { jarFiles.addAll(mClient.findRuleJars(project)); } jarFiles.addAll(mClient.findGlobalRuleJars()); if (!jarFiles.isEmpty()) { List<IssueRegistry> registries = Lists.newArrayListWithExpectedSize(jarFiles.size()); registries.add(mRegistry); for (File jarFile : jarFiles) { try { registries.add(JarFileIssueRegistry.get(mClient, jarFile)); } catch (Throwable e) { mClient.log(e, "Could not load custom rule jar file %1$s", jarFile); } } if (registries.size() > 1) { // the first item is mRegistry itself mRegistry = new CompositeIssueRegistry(registries); } } } private void runExtraPhases(@NonNull Project project, @NonNull Project main) { // Did any detectors request another phase? if (mRepeatingDetectors != null) { // Yes. Iterate up to MAX_PHASES times. // During the extra phases, we might be narrowing the scope, and setting it in the // scope field such that detectors asking about the available scope will get the // correct result. However, we need to restore it to the original scope when this // is done in case there are other projects that will be checked after this, since // the repeated phases is done *per project*, not after all projects have been // processed. EnumSet<Scope> oldScope = mScope; do { mPhase++; fireEvent(LintListener.EventType.NEW_PHASE, new Context(this, project, null, project.getDir())); // Narrow the scope down to the set of scopes requested by // the rules. if (mRepeatScope == null) { mRepeatScope = Scope.ALL; } mScope = Scope.intersect(mScope, mRepeatScope); if (mScope.isEmpty()) { break; } // Compute the detectors to use for this pass. // Unlike the normal computeDetectors(project) call, // this is going to use the existing instances, and include // those that apply for the configuration. computeRepeatingDetectors(mRepeatingDetectors, project); if (mApplicableDetectors.isEmpty()) { // No detectors enabled in this project: skip it continue; } checkProject(project, main); if (mCanceled) { break; } } while (mPhase < MAX_PHASES && mRepeatingDetectors != null); mScope = oldScope; } } private void computeRepeatingDetectors(List<Detector> detectors, Project project) { // Ensure that the current visitor is recomputed mCurrentFolderType = null; mCurrentVisitor = null; mCurrentXmlDetectors = null; mCurrentBinaryDetectors = null; // Create map from detector class to issue such that we can // compute applicable issues for each detector in the list of detectors // to be repeated List<Issue> issues = mRegistry.getIssues(); Multimap<Class<? extends Detector>, Issue> issueMap = ArrayListMultimap.create(issues.size(), 3); for (Issue issue : issues) { issueMap.put(issue.getImplementation().getDetectorClass(), issue); } Map<Class<? extends Detector>, EnumSet<Scope>> detectorToScope = new HashMap<Class<? extends Detector>, EnumSet<Scope>>(); Map<Scope, List<Detector>> scopeToDetectors = new EnumMap<Scope, List<Detector>>(Scope.class); List<Detector> detectorList = new ArrayList<Detector>(); // Compute the list of detectors (narrowed down from mRepeatingDetectors), // and simultaneously build up the detectorToScope map which tracks // the scopes each detector is affected by (this is used to populate // the mScopeDetectors map which is used during iteration). Configuration configuration = project.getConfiguration(); for (Detector detector : detectors) { Class<? extends Detector> detectorClass = detector.getClass(); Collection<Issue> detectorIssues = issueMap.get(detectorClass); if (detectorIssues != null) { boolean add = false; for (Issue issue : detectorIssues) { // The reason we have to check whether the detector is enabled // is that this is a per-project property, so when running lint in multiple // projects, a detector enabled only in a different project could have // requested another phase, and we end up in this project checking whether // the detector is enabled here. if (!configuration.isEnabled(issue)) { continue; } add = true; // Include detector if any of its issues are enabled EnumSet<Scope> s = detectorToScope.get(detectorClass); EnumSet<Scope> issueScope = issue.getImplementation().getScope(); if (s == null) { detectorToScope.put(detectorClass, issueScope); } else if (!s.containsAll(issueScope)) { EnumSet<Scope> union = EnumSet.copyOf(s); union.addAll(issueScope); detectorToScope.put(detectorClass, union); } } if (add) { detectorList.add(detector); EnumSet<Scope> union = detectorToScope.get(detector.getClass()); for (Scope s : union) { List<Detector> list = scopeToDetectors.get(s); if (list == null) { list = new ArrayList<Detector>(); scopeToDetectors.put(s, list); } list.add(detector); } } } } mApplicableDetectors = detectorList; mScopeDetectors = scopeToDetectors; mRepeatingDetectors = null; mRepeatScope = null; validateScopeList(); } private void computeDetectors(@NonNull Project project) { // Ensure that the current visitor is recomputed mCurrentFolderType = null; mCurrentVisitor = null; Configuration configuration = project.getConfiguration(); mScopeDetectors = new EnumMap<Scope, List<Detector>>(Scope.class); mApplicableDetectors = mRegistry.createDetectors(mClient, configuration, mScope, mScopeDetectors); validateScopeList(); } /** Development diagnostics only, run with assertions on */ @SuppressWarnings("all") // Turn off warnings for the intentional assertion side effect below private void validateScopeList() { boolean assertionsEnabled = false; assert assertionsEnabled = true; // Intentional side-effect if (assertionsEnabled) { List<Detector> resourceFileDetectors = mScopeDetectors.get(Scope.RESOURCE_FILE); if (resourceFileDetectors != null) { for (Detector detector : resourceFileDetectors) { assert detector instanceof ResourceXmlDetector : detector; } } List<Detector> manifestDetectors = mScopeDetectors.get(Scope.MANIFEST); if (manifestDetectors != null) { for (Detector detector : manifestDetectors) { assert detector instanceof Detector.XmlScanner : detector; } } List<Detector> javaCodeDetectors = mScopeDetectors.get(Scope.ALL_SOURCE_FILES); if (javaCodeDetectors != null) { for (Detector detector : javaCodeDetectors) { assert (detector instanceof UastScanner) : detector; } } List<Detector> javaFileDetectors = mScopeDetectors.get(Scope.SOURCE_FILE); if (javaFileDetectors != null) { for (Detector detector : javaFileDetectors) { assert (detector instanceof UastScanner) : detector; } } List<Detector> classDetectors = mScopeDetectors.get(Scope.CLASS_FILE); if (classDetectors != null) { for (Detector detector : classDetectors) { assert detector instanceof Detector.ClassScanner : detector; } } List<Detector> classCodeDetectors = mScopeDetectors.get(Scope.ALL_CLASS_FILES); if (classCodeDetectors != null) { for (Detector detector : classCodeDetectors) { assert detector instanceof Detector.ClassScanner : detector; } } List<Detector> gradleDetectors = mScopeDetectors.get(Scope.GRADLE_FILE); if (gradleDetectors != null) { for (Detector detector : gradleDetectors) { assert detector instanceof Detector.GradleScanner : detector; } } List<Detector> otherDetectors = mScopeDetectors.get(Scope.OTHER); if (otherDetectors != null) { for (Detector detector : otherDetectors) { assert detector instanceof Detector.OtherFileScanner : detector; } } List<Detector> dirDetectors = mScopeDetectors.get(Scope.RESOURCE_FOLDER); if (dirDetectors != null) { for (Detector detector : dirDetectors) { assert detector instanceof Detector.ResourceFolderScanner : detector; } } List<Detector> binaryDetectors = mScopeDetectors.get(Scope.BINARY_RESOURCE_FILE); if (binaryDetectors != null) { for (Detector detector : binaryDetectors) { assert detector instanceof Detector.BinaryResourceScanner : detector; } } } } private void registerProjectFile(@NonNull Map<File, Project> fileToProject, @NonNull File file, @NonNull File projectDir, @NonNull File rootDir) { fileToProject.put(file, mClient.getProject(projectDir, rootDir)); } private Collection<Project> computeProjects(@NonNull List<File> files) { // Compute list of projects Map<File, Project> fileToProject = new LinkedHashMap<File, Project>(); File sharedRoot = null; // Ensure that we have absolute paths such that if you lint // "foo bar" in "baz" we can show baz/ as the root if (files.size() > 1) { List<File> absolute = new ArrayList<File>(files.size()); for (File file : files) { absolute.add(file.getAbsoluteFile()); } files = absolute; sharedRoot = LintUtils.getCommonParent(files); if (sharedRoot != null && sharedRoot.getParentFile() == null) { // "/" ? sharedRoot = null; } } for (File file : files) { if (file.isDirectory()) { File rootDir = sharedRoot; if (rootDir == null) { rootDir = file; if (files.size() > 1) { rootDir = file.getParentFile(); if (rootDir == null) { rootDir = file; } } } // Figure out what to do with a directory. Note that the meaning of the // directory can be ambiguous: // If you pass a directory which is unknown, we don't know if we should // search upwards (in case you're pointing at a deep java package folder // within the project), or if you're pointing at some top level directory // containing lots of projects you want to scan. We attempt to do the // right thing, which is to see if you're pointing right at a project or // right within it (say at the src/ or res/) folder, and if not, you're // hopefully pointing at a project tree that you want to scan recursively. if (mClient.isProjectDirectory(file)) { registerProjectFile(fileToProject, file, file, rootDir); continue; } else { File parent = file.getParentFile(); if (parent != null) { if (mClient.isProjectDirectory(parent)) { registerProjectFile(fileToProject, file, parent, parent); continue; } else { parent = parent.getParentFile(); if (parent != null && mClient.isProjectDirectory(parent)) { registerProjectFile(fileToProject, file, parent, parent); continue; } } } // Search downwards for nested projects addProjects(file, fileToProject, rootDir); } } else { // Pointed at a file: Search upwards for the containing project File parent = file.getParentFile(); while (parent != null) { if (mClient.isProjectDirectory(parent)) { registerProjectFile(fileToProject, file, parent, parent); break; } parent = parent.getParentFile(); } } if (mCanceled) { return Collections.emptySet(); } } for (Map.Entry<File, Project> entry : fileToProject.entrySet()) { File file = entry.getKey(); Project project = entry.getValue(); if (!file.equals(project.getDir())) { if (file.isDirectory()) { try { File dir = file.getCanonicalFile(); if (dir.equals(project.getDir())) { continue; } } catch (IOException ioe) { // pass } } project.addFile(file); } } // Partition the projects up such that we only return projects that aren't // included by other projects (e.g. because they are library projects) Collection<Project> allProjects = fileToProject.values(); Set<Project> roots = new HashSet<Project>(allProjects); for (Project project : allProjects) { roots.removeAll(project.getAllLibraries()); } // Report issues for all projects that are explicitly referenced. We need to // do this here, since the project initialization will mark all library // projects as no-report projects by default. for (Project project : allProjects) { // Report issues for all projects explicitly listed or found via a directory // traversal -- including library projects. project.setReportIssues(true); } if (LintUtils.assertionsEnabled()) { // Make sure that all the project directories are unique. This ensures // that we didn't accidentally end up with different project instances // for a library project discovered as a directory as well as one // initialized from the library project dependency list IdentityHashMap<Project, Project> projects = new IdentityHashMap<Project, Project>(); for (Project project : roots) { projects.put(project, project); for (Project library : project.getAllLibraries()) { projects.put(library, library); } } Set<File> dirs = new HashSet<File>(); for (Project project : projects.keySet()) { assert !dirs.contains(project.getDir()); dirs.add(project.getDir()); } } return roots; } private void addProjects(@NonNull File dir, @NonNull Map<File, Project> fileToProject, @NonNull File rootDir) { if (mCanceled) { return; } if (mClient.isProjectDirectory(dir)) { registerProjectFile(fileToProject, dir, dir, rootDir); } else { File[] files = dir.listFiles(); if (files != null) { for (File file : files) { if (file.isDirectory()) { addProjects(file, fileToProject, rootDir); } } } } } private void checkProject(@NonNull Project project, @NonNull Project main) { File projectDir = project.getDir(); Context projectContext = new Context(this, project, null, projectDir); fireEvent(LintListener.EventType.SCANNING_PROJECT, projectContext); List<Project> allLibraries = project.getAllLibraries(); Set<Project> allProjects = new HashSet<Project>(allLibraries.size() + 1); allProjects.add(project); allProjects.addAll(allLibraries); mCurrentProjects = allProjects.toArray(new Project[allProjects.size()]); mCurrentProject = project; for (Detector check : mApplicableDetectors) { check.beforeCheckProject(projectContext); if (mCanceled) { return; } } assert mCurrentProject == project; runFileDetectors(project, main); if (!Scope.checkSingleFile(mScope)) { List<Project> libraries = project.getAllLibraries(); for (Project library : libraries) { Context libraryContext = new Context(this, library, project, projectDir); fireEvent(LintListener.EventType.SCANNING_LIBRARY_PROJECT, libraryContext); mCurrentProject = library; for (Detector check : mApplicableDetectors) { check.beforeCheckLibraryProject(libraryContext); if (mCanceled) { return; } } assert mCurrentProject == library; runFileDetectors(library, main); if (mCanceled) { return; } assert mCurrentProject == library; for (Detector check : mApplicableDetectors) { check.afterCheckLibraryProject(libraryContext); if (mCanceled) { return; } } } } mCurrentProject = project; for (Detector check : mApplicableDetectors) { check.afterCheckProject(projectContext); if (mCanceled) { return; } } if (mCanceled) { mClient.report(projectContext, // Must provide an issue since API guarantees that the issue parameter IssueRegistry.CANCELLED, Severity.INFORMATIONAL, null /*range*/, "Lint canceled by user", TextFormat.RAW); } mCurrentProjects = null; } private void runFileDetectors(@NonNull Project project, @Nullable Project main) { // Look up manifest information (but not for library projects) if (project.isAndroidProject()) { for (File manifestFile : project.getManifestFiles()) { XmlParser parser = mClient.getXmlParser(); if (parser != null) { XmlContext context = new XmlContext(this, project, main, manifestFile, null, parser); context.document = parser.parseXml(context); if (context.document != null) { try { project.readManifest(context.document); if ((!project.isLibrary() || (main != null && main.isMergingManifests())) && mScope.contains(Scope.MANIFEST)) { List<Detector> detectors = mScopeDetectors.get(Scope.MANIFEST); if (detectors != null) { ResourceVisitor v = new ResourceVisitor(parser, detectors, null); fireEvent(LintListener.EventType.SCANNING_FILE, context); v.visitFile(context, manifestFile); } } } finally { if (context.document != null) { // else: freed by XmlVisitor above parser.dispose(context, context.document); } } } } } // Process both Scope.RESOURCE_FILE and Scope.ALL_RESOURCE_FILES detectors together // in a single pass through the resource directories. if (mScope.contains(Scope.ALL_RESOURCE_FILES) || mScope.contains(Scope.RESOURCE_FILE) || mScope.contains(Scope.RESOURCE_FOLDER) || mScope.contains(Scope.BINARY_RESOURCE_FILE)) { List<Detector> dirChecks = mScopeDetectors.get(Scope.RESOURCE_FOLDER); List<Detector> binaryChecks = mScopeDetectors.get(Scope.BINARY_RESOURCE_FILE); List<Detector> checks = union(mScopeDetectors.get(Scope.RESOURCE_FILE), mScopeDetectors.get(Scope.ALL_RESOURCE_FILES)); boolean haveXmlChecks = checks != null && !checks.isEmpty(); List<ResourceXmlDetector> xmlDetectors; if (haveXmlChecks) { xmlDetectors = new ArrayList<ResourceXmlDetector>(checks.size()); for (Detector detector : checks) { if (detector instanceof ResourceXmlDetector) { xmlDetectors.add((ResourceXmlDetector) detector); } } haveXmlChecks = !xmlDetectors.isEmpty(); } else { xmlDetectors = Collections.emptyList(); } if (haveXmlChecks || dirChecks != null && !dirChecks.isEmpty() || binaryChecks != null && !binaryChecks.isEmpty()) { List<File> files = project.getSubset(); if (files != null) { checkIndividualResources(project, main, xmlDetectors, dirChecks, binaryChecks, files); } else { List<File> resourceFolders = project.getResourceFolders(); if (!resourceFolders.isEmpty()) { for (File res : resourceFolders) { checkResFolder(project, main, res, xmlDetectors, dirChecks, binaryChecks); } } } } } if (mCanceled) { return; } } if (mScope.contains(Scope.SOURCE_FILE) || mScope.contains(Scope.ALL_SOURCE_FILES)) { List<Detector> checks = union(mScopeDetectors.get(Scope.SOURCE_FILE), mScopeDetectors.get(Scope.ALL_SOURCE_FILES)); if (checks != null && !checks.isEmpty()) { List<File> files = project.getSubset(); if (files != null) { checkIndividualJavaFiles(project, main, checks, files); } else { List<File> sourceFolders = project.getJavaSourceFolders(); if (mScope.contains(Scope.TEST_SOURCES)) { List<File> testFolders = project.getTestSourceFolders(); if (!testFolders.isEmpty()) { List<File> combined = Lists .newArrayListWithExpectedSize(sourceFolders.size() + testFolders.size()); combined.addAll(sourceFolders); combined.addAll(testFolders); sourceFolders = combined; } } checkJava(project, main, sourceFolders, checks); } } } if (mCanceled) { return; } if (mScope.contains(Scope.CLASS_FILE) || mScope.contains(Scope.ALL_CLASS_FILES) || mScope.contains(Scope.JAVA_LIBRARIES)) { checkClasses(project, main); } if (mCanceled) { return; } if (mScope.contains(Scope.GRADLE_FILE)) { checkBuildScripts(project, main); } if (mCanceled) { return; } if (mScope.contains(Scope.OTHER)) { List<Detector> checks = mScopeDetectors.get(Scope.OTHER); if (checks != null) { OtherFileVisitor visitor = new OtherFileVisitor(checks); visitor.scan(this, project, main); } } if (mCanceled) { return; } if (project == main && mScope.contains(Scope.PROGUARD_FILE) && project.isAndroidProject()) { checkProGuard(project, main); } if (project == main && mScope.contains(Scope.PROPERTY_FILE)) { checkProperties(project, main); } } private void checkBuildScripts(Project project, Project main) { List<Detector> detectors = mScopeDetectors.get(Scope.GRADLE_FILE); if (detectors != null) { List<File> files = project.getSubset(); if (files == null) { files = project.getGradleBuildScripts(); } for (File file : files) { Context context = new Context(this, project, main, file); fireEvent(LintListener.EventType.SCANNING_FILE, context); for (Detector detector : detectors) { if (detector.appliesTo(context, file)) { detector.beforeCheckFile(context); detector.visitBuildScript(context, Maps.<String, Object>newHashMap()); detector.afterCheckFile(context); } } } } } private void checkProGuard(Project project, Project main) { List<Detector> detectors = mScopeDetectors.get(Scope.PROGUARD_FILE); if (detectors != null) { List<File> files = project.getProguardFiles(); for (File file : files) { Context context = new Context(this, project, main, file); fireEvent(LintListener.EventType.SCANNING_FILE, context); for (Detector detector : detectors) { if (detector.appliesTo(context, file)) { detector.beforeCheckFile(context); detector.run(context); detector.afterCheckFile(context); } } } } } private void checkProperties(Project project, Project main) { List<Detector> detectors = mScopeDetectors.get(Scope.PROPERTY_FILE); if (detectors != null) { checkPropertyFile(project, main, detectors, FN_LOCAL_PROPERTIES); checkPropertyFile(project, main, detectors, FD_GRADLE_WRAPPER + separator + FN_GRADLE_WRAPPER_PROPERTIES); } } private void checkPropertyFile(Project project, Project main, List<Detector> detectors, String relativePath) { File file = new File(project.getDir(), relativePath); if (file.exists()) { Context context = new Context(this, project, main, file); fireEvent(LintListener.EventType.SCANNING_FILE, context); for (Detector detector : detectors) { if (detector.appliesTo(context, file)) { detector.beforeCheckFile(context); detector.run(context); detector.afterCheckFile(context); } } } } /** True if execution has been canceled */ boolean isCanceled() { return mCanceled; } /** * Returns the super class for the given class name, * which should be in VM format (e.g. java/lang/Integer, not java.lang.Integer). * If the super class is not known, returns null. This can happen if * the given class is not a known class according to the project or its * libraries, for example because it refers to one of the core libraries which * are not analyzed by lint. * * @param name the fully qualified class name * @return the corresponding super class name (in VM format), or null if not known */ @Nullable public String getSuperClass(@NonNull String name) { return mClient.getSuperClass(mCurrentProject, name); } /** * Returns true if the given class is a subclass of the given super class. * * @param classNode the class to check whether it is a subclass of the given * super class name * @param superClassName the fully qualified super class name (in VM format, * e.g. java/lang/Integer, not java.lang.Integer. * @return true if the given class is a subclass of the given super class */ public boolean isSubclassOf(@NonNull ClassNode classNode, @NonNull String superClassName) { if (superClassName.equals(classNode.superName)) { return true; } if (mCurrentProject != null) { Boolean isSub = mClient.isSubclassOf(mCurrentProject, classNode.name, superClassName); if (isSub != null) { return isSub; } } String className = classNode.name; while (className != null) { if (className.equals(superClassName)) { return true; } className = getSuperClass(className); } return false; } @Nullable private static List<Detector> union(@Nullable List<Detector> list1, @Nullable List<Detector> list2) { if (list1 == null) { return list2; } else if (list2 == null) { return list1; } else { // Use set to pick out unique detectors, since it's possible for there to be overlap, // e.g. the DuplicateIdDetector registers both a cross-resource issue and a // single-file issue, so it shows up on both scope lists: Set<Detector> set = new HashSet<Detector>(list1.size() + list2.size()); set.addAll(list1); set.addAll(list2); return new ArrayList<Detector>(set); } } /** Check the classes in this project (and if applicable, in any library projects */ private void checkClasses(Project project, Project main) { List<File> files = project.getSubset(); if (files != null) { checkIndividualClassFiles(project, main, files); return; } // We need to read in all the classes up front such that we can initialize // the parent chains (such that for example for a virtual dispatch, we can // also check the super classes). List<File> libraries = project.getJavaLibraries(); List<ClassEntry> libraryEntries = ClassEntry.fromClassPath(mClient, libraries, true); List<File> classFolders = project.getJavaClassFolders(); List<ClassEntry> classEntries; if (classFolders.isEmpty()) { String message = String.format("No `.class` files were found in project \"%1$s\", " + "so none of the classfile based checks could be run. " + "Does the project need to be built first?", project.getName()); Location location = Location.create(project.getDir()); mClient.report(new Context(this, project, main, project.getDir()), IssueRegistry.LINT_ERROR, project.getConfiguration().getSeverity(IssueRegistry.LINT_ERROR), location, message, TextFormat.RAW); classEntries = Collections.emptyList(); } else { classEntries = ClassEntry.fromClassPath(mClient, classFolders, true); } // Actually run the detectors. Libraries should be called before the // main classes. runClassDetectors(Scope.JAVA_LIBRARIES, libraryEntries, project, main); if (mCanceled) { return; } runClassDetectors(Scope.CLASS_FILE, classEntries, project, main); runClassDetectors(Scope.ALL_CLASS_FILES, classEntries, project, main); } private void checkIndividualClassFiles(@NonNull Project project, @Nullable Project main, @NonNull List<File> files) { List<File> classFiles = Lists.newArrayListWithExpectedSize(files.size()); List<File> classFolders = project.getJavaClassFolders(); if (!classFolders.isEmpty()) { for (File file : files) { String path = file.getPath(); if (file.isFile() && path.endsWith(DOT_CLASS)) { classFiles.add(file); } } } List<ClassEntry> entries = ClassEntry.fromClassFiles(mClient, classFiles, classFolders, true); if (!entries.isEmpty()) { Collections.sort(entries); runClassDetectors(Scope.CLASS_FILE, entries, project, main); } } /** * Stack of {@link ClassNode} nodes for outer classes of the currently * processed class, including that class itself. Populated by * {@link #runClassDetectors(Scope, List, Project, Project)} and used by * {@link #getOuterClassNode(ClassNode)} */ private Deque<ClassNode> mOuterClasses; private void runClassDetectors(Scope scope, List<ClassEntry> entries, Project project, Project main) { if (mScope.contains(scope)) { List<Detector> classDetectors = mScopeDetectors.get(scope); if (classDetectors != null && !classDetectors.isEmpty() && !entries.isEmpty()) { AsmVisitor visitor = new AsmVisitor(mClient, classDetectors); String sourceContents = null; String sourceName = ""; mOuterClasses = new ArrayDeque<ClassNode>(); ClassEntry prev = null; for (ClassEntry entry : entries) { if (prev != null && prev.compareTo(entry) == 0) { // Duplicate entries for some reason: ignore continue; } prev = entry; ClassReader reader; ClassNode classNode; try { reader = new ClassReader(entry.bytes); classNode = new ClassNode(); reader.accept(classNode, 0 /* flags */); } catch (Throwable t) { mClient.log(null, "Error processing %1$s: broken class file?", entry.path()); continue; } ClassNode peek; while ((peek = mOuterClasses.peek()) != null) { if (classNode.name.startsWith(peek.name)) { break; } else { mOuterClasses.pop(); } } mOuterClasses.push(classNode); if (isSuppressed(null, classNode)) { // Class was annotated with suppress all -- no need to look any further continue; } if (sourceContents != null) { // Attempt to reuse the source buffer if initialized // This means making sure that the source files // foo/bar/MyClass and foo/bar/MyClass$Bar // and foo/bar/MyClass$3 and foo/bar/MyClass$3$1 have the same prefix. String newName = classNode.name; int newRootLength = newName.indexOf('$'); if (newRootLength == -1) { newRootLength = newName.length(); } int oldRootLength = sourceName.indexOf('$'); if (oldRootLength == -1) { oldRootLength = sourceName.length(); } if (newRootLength != oldRootLength || !sourceName.regionMatches(0, newName, 0, newRootLength)) { sourceContents = null; } } ClassContext context = new ClassContext(this, project, main, entry.file, entry.jarFile, entry.binDir, entry.bytes, classNode, scope == Scope.JAVA_LIBRARIES /*fromLibrary*/, sourceContents); try { visitor.runClassDetectors(context); } catch (Exception e) { mClient.log(e, null); } if (mCanceled) { return; } sourceContents = context.getSourceContents(false/*read*/); sourceName = classNode.name; } mOuterClasses = null; } } } /** Returns the outer class node of the given class node * @param classNode the inner class node * @return the outer class node */ public ClassNode getOuterClassNode(@NonNull ClassNode classNode) { String outerName = classNode.outerClass; Iterator<ClassNode> iterator = mOuterClasses.iterator(); while (iterator.hasNext()) { ClassNode node = iterator.next(); if (outerName != null) { if (node.name.equals(outerName)) { return node; } } else if (node == classNode) { return iterator.hasNext() ? iterator.next() : null; } } return null; } /** * Returns the {@link ClassNode} corresponding to the given type, if possible, or null * * @param type the fully qualified type, using JVM signatures (/ and $, not . as path * separators) * @param flags the ASM flags to pass to the {@link ClassReader}, normally 0 but can * for example be {@link ClassReader#SKIP_CODE} and/oor * {@link ClassReader#SKIP_DEBUG} * @return the class node for the type, or null */ @Nullable public ClassNode findClass(@NonNull ClassContext context, @NonNull String type, int flags) { String relative = type.replace('/', File.separatorChar) + DOT_CLASS; File classFile = findClassFile(context.getProject(), relative); if (classFile != null) { if (classFile.getPath().endsWith(DOT_JAR)) { // TODO: Handle .jar files return null; } try { byte[] bytes = mClient.readBytes(classFile); ClassReader reader = new ClassReader(bytes); ClassNode classNode = new ClassNode(); reader.accept(classNode, flags); return classNode; } catch (Throwable t) { mClient.log(null, "Error processing %1$s: broken class file?", classFile.getPath()); } } return null; } @Nullable private File findClassFile(@NonNull Project project, String relativePath) { for (File root : mClient.getJavaClassFolders(project)) { File path = new File(root, relativePath); if (path.exists()) { return path; } } // Search in the libraries for (File root : mClient.getJavaLibraries(project)) { // TODO: Handle .jar files! //if (root.getPath().endsWith(DOT_JAR)) { //} File path = new File(root, relativePath); if (path.exists()) { return path; } } // Search dependent projects for (Project library : project.getDirectLibraries()) { File path = findClassFile(library, relativePath); if (path != null) { return path; } } return null; } private void checkJava(@NonNull Project project, @Nullable Project main, @NonNull List<File> sourceFolders, @NonNull List<Detector> checks) { assert !checks.isEmpty(); // Gather all Java source files in a single pass; more efficient. List<File> sources = new ArrayList<File>(100); for (File folder : sourceFolders) { gatherJavaFiles(folder, sources); } if (!sources.isEmpty()) { List<JavaContext> contexts = Lists.newArrayListWithExpectedSize(sources.size()); for (File file : sources) { JavaContext context = new JavaContext(this, project, main, file); contexts.add(context); } com.intellij.openapi.project.Project ideaProject = mClient.getProject(); if (ideaProject == null) { return; } for (JavaContext context : contexts) { fireEvent(LintListener.EventType.SCANNING_FILE, context); for (Detector check : checks) { if (check instanceof UastScanner) { UastScanner scanner = (UastScanner) check; UastVisitor customVisitor = scanner.createUastVisitor(context); if (customVisitor != null) { UastChecker.INSTANCE.check(ideaProject, context.file, context, customVisitor); } else { UastChecker.INSTANCE.check(ideaProject, context.file, (UastScanner) check, context); } } } if (mCanceled) { return; } } } } private void checkIndividualJavaFiles(@NonNull Project project, @Nullable Project main, @NonNull List<Detector> checks, @NonNull List<File> files) { List<UastScanner> uastDetectors = new ArrayList<UastScanner>(); for (Detector check : checks) { if (check instanceof UastScanner) { uastDetectors.add((UastScanner) check); } } checkWithUastDetectors(project, main, uastDetectors, files); } private void checkWithUastDetectors(@NotNull Project project, @Nullable Project main, @NotNull List<UastScanner> detectors, @NotNull List<File> files) { com.intellij.openapi.project.Project intellijProject = mClient.getProject(); if (intellijProject == null) { return; } UastChecker checker = UastChecker.INSTANCE; List<UastLanguagePlugin> plugins = project.getClient().getLanguagePlugins(); for (File file : files) { if (!file.isFile()) { continue; } String filename = file.getName(); // Ignore Java files for now (check only Kotlin files) if (filename.endsWith(DOT_JAVA) || !UastConverterUtils.isFileSupported(plugins, filename)) { continue; } JavaContext context = new JavaContext(this, project, main, file); for (UastScanner detector : detectors) { UastVisitor customHandler = detector.createUastVisitor(context); if (customHandler != null) { checker.check(intellijProject, file, context, customHandler); } else { checker.check(intellijProject, file, detector, context); } } } } private static void gatherJavaFiles(@NonNull File dir, @NonNull List<File> result) { File[] files = dir.listFiles(); if (files != null) { for (File file : files) { if (file.isFile() && file.getName().endsWith(".java")) { //$NON-NLS-1$ result.add(file); } else if (file.isDirectory()) { gatherJavaFiles(file, result); } } } } private ResourceFolderType mCurrentFolderType; private List<ResourceXmlDetector> mCurrentXmlDetectors; private List<Detector> mCurrentBinaryDetectors; private ResourceVisitor mCurrentVisitor; @Nullable private ResourceVisitor getVisitor(@NonNull ResourceFolderType type, @NonNull List<ResourceXmlDetector> checks, @Nullable List<Detector> binaryChecks) { if (type != mCurrentFolderType) { mCurrentFolderType = type; // Determine which XML resource detectors apply to the given folder type List<ResourceXmlDetector> applicableXmlChecks = new ArrayList<ResourceXmlDetector>(checks.size()); for (ResourceXmlDetector check : checks) { if (check.appliesTo(type)) { applicableXmlChecks.add(check); } } List<Detector> applicableBinaryChecks = null; if (binaryChecks != null) { applicableBinaryChecks = new ArrayList<Detector>(binaryChecks.size()); for (Detector check : binaryChecks) { if (check.appliesTo(type)) { applicableBinaryChecks.add(check); } } } // If the list of detectors hasn't changed, then just use the current visitor! if (mCurrentXmlDetectors != null && mCurrentXmlDetectors.equals(applicableXmlChecks) && Objects.equal(mCurrentBinaryDetectors, applicableBinaryChecks)) { return mCurrentVisitor; } mCurrentXmlDetectors = applicableXmlChecks; mCurrentBinaryDetectors = applicableBinaryChecks; if (applicableXmlChecks.isEmpty() && (applicableBinaryChecks == null || applicableBinaryChecks.isEmpty())) { mCurrentVisitor = null; return null; } XmlParser parser = mClient.getXmlParser(); if (parser != null) { mCurrentVisitor = new ResourceVisitor(parser, applicableXmlChecks, applicableBinaryChecks); } else { mCurrentVisitor = null; } } return mCurrentVisitor; } private void checkResFolder(@NonNull Project project, @Nullable Project main, @NonNull File res, @NonNull List<ResourceXmlDetector> xmlChecks, @Nullable List<Detector> dirChecks, @Nullable List<Detector> binaryChecks) { File[] resourceDirs = res.listFiles(); if (resourceDirs == null) { return; } // Sort alphabetically such that we can process related folder types at the // same time, and to have a defined behavior such that detectors can rely on // predictable ordering, e.g. layouts are seen before menus are seen before // values, etc (l < m < v). Arrays.sort(resourceDirs); for (File dir : resourceDirs) { ResourceFolderType type = ResourceFolderType.getFolderType(dir.getName()); if (type != null) { checkResourceFolder(project, main, dir, type, xmlChecks, dirChecks, binaryChecks); } if (mCanceled) { return; } } } private void checkResourceFolder(@NonNull Project project, @Nullable Project main, @NonNull File dir, @NonNull ResourceFolderType type, @NonNull List<ResourceXmlDetector> xmlChecks, @Nullable List<Detector> dirChecks, @Nullable List<Detector> binaryChecks) { // Process the resource folder if (dirChecks != null && !dirChecks.isEmpty()) { ResourceContext context = new ResourceContext(this, project, main, dir, type); String folderName = dir.getName(); fireEvent(LintListener.EventType.SCANNING_FILE, context); for (Detector check : dirChecks) { if (check.appliesTo(type)) { check.beforeCheckFile(context); check.checkFolder(context, folderName); check.afterCheckFile(context); } } if (binaryChecks == null && xmlChecks.isEmpty()) { return; } } File[] files = dir.listFiles(); if (files == null || files.length <= 0) { return; } ResourceVisitor visitor = getVisitor(type, xmlChecks, binaryChecks); if (visitor != null) { // if not, there are no applicable rules in this folder // Process files in alphabetical order, to ensure stable output // (for example for the duplicate resource detector) Arrays.sort(files); for (File file : files) { if (LintUtils.isXmlFile(file)) { XmlContext context = new XmlContext(this, project, main, file, type, visitor.getParser()); fireEvent(LintListener.EventType.SCANNING_FILE, context); visitor.visitFile(context, file); } else if (binaryChecks != null && LintUtils.isBitmapFile(file)) { ResourceContext context = new ResourceContext(this, project, main, file, type); fireEvent(LintListener.EventType.SCANNING_FILE, context); visitor.visitBinaryResource(context); } if (mCanceled) { return; } } } } /** Checks individual resources */ private void checkIndividualResources(@NonNull Project project, @Nullable Project main, @NonNull List<ResourceXmlDetector> xmlDetectors, @Nullable List<Detector> dirChecks, @Nullable List<Detector> binaryChecks, @NonNull List<File> files) { for (File file : files) { if (file.isDirectory()) { // Is it a resource folder? ResourceFolderType type = ResourceFolderType.getFolderType(file.getName()); if (type != null && new File(file.getParentFile(), RES_FOLDER).exists()) { // Yes. checkResourceFolder(project, main, file, type, xmlDetectors, dirChecks, binaryChecks); } else if (file.getName().equals(RES_FOLDER)) { // Is it the res folder? // Yes checkResFolder(project, main, file, xmlDetectors, dirChecks, binaryChecks); } else { mClient.log(null, "Unexpected folder %1$s; should be project, " + "\"res\" folder or resource folder", file.getPath()); } } else if (file.isFile() && LintUtils.isXmlFile(file)) { // Yes, find out its resource type String folderName = file.getParentFile().getName(); ResourceFolderType type = ResourceFolderType.getFolderType(folderName); if (type != null) { ResourceVisitor visitor = getVisitor(type, xmlDetectors, binaryChecks); if (visitor != null) { XmlContext context = new XmlContext(this, project, main, file, type, visitor.getParser()); fireEvent(LintListener.EventType.SCANNING_FILE, context); visitor.visitFile(context, file); } } } else if (binaryChecks != null && file.isFile() && LintUtils.isBitmapFile(file)) { // Yes, find out its resource type String folderName = file.getParentFile().getName(); ResourceFolderType type = ResourceFolderType.getFolderType(folderName); if (type != null) { ResourceVisitor visitor = getVisitor(type, xmlDetectors, binaryChecks); if (visitor != null) { ResourceContext context = new ResourceContext(this, project, main, file, type); fireEvent(LintListener.EventType.SCANNING_FILE, context); visitor.visitBinaryResource(context); if (mCanceled) { return; } } } } } } /** * Adds a listener to be notified of lint progress * * @param listener the listener to be added */ public void addLintListener(@NonNull LintListener listener) { if (mListeners == null) { mListeners = new ArrayList<LintListener>(1); } mListeners.add(listener); } /** * Removes a listener such that it is no longer notified of progress * * @param listener the listener to be removed */ public void removeLintListener(@NonNull LintListener listener) { mListeners.remove(listener); if (mListeners.isEmpty()) { mListeners = null; } } /** Notifies listeners, if any, that the given event has occurred */ private void fireEvent(@NonNull LintListener.EventType type, @Nullable Context context) { if (mListeners != null) { for (LintListener listener : mListeners) { listener.update(this, type, context); } } } /** * Wrapper around the lint client. This sits in the middle between a * detector calling for example {@link LintClient#report} and * the actual embedding tool, and performs filtering etc such that detectors * and lint clients don't have to make sure they check for ignored issues or * filtered out warnings. */ private class LintClientWrapper extends LintClient { @NonNull private final LintClient mDelegate; public LintClientWrapper(@NonNull LintClient delegate) { mDelegate = delegate; } @Override public void report(@NonNull Context context, @NonNull Issue issue, @NonNull Severity severity, @Nullable Location location, @NonNull String message, @NonNull TextFormat format) { assert mCurrentProject != null; if (!mCurrentProject.getReportIssues()) { return; } Configuration configuration = context.getConfiguration(); if (!configuration.isEnabled(issue)) { if (issue != IssueRegistry.PARSER_ERROR && issue != IssueRegistry.LINT_ERROR) { mDelegate.log(null, "Incorrect detector reported disabled issue %1$s", issue.toString()); } return; } if (configuration.isIgnored(context, issue, location, message)) { return; } if (severity == Severity.IGNORE) { return; } mDelegate.report(context, issue, severity, location, message, format); } // Everything else just delegates to the embedding lint client @Override @NonNull public Configuration getConfiguration(@NonNull Project project) { return mDelegate.getConfiguration(project); } @Override public void log(@NonNull Severity severity, @Nullable Throwable exception, @Nullable String format, @Nullable Object... args) { mDelegate.log(exception, format, args); } @Override @NonNull public String readFile(@NonNull File file) { return mDelegate.readFile(file); } @Override @NonNull public byte[] readBytes(@NonNull File file) throws IOException { return mDelegate.readBytes(file); } @Override @NonNull public List<File> getJavaSourceFolders(@NonNull Project project) { return mDelegate.getJavaSourceFolders(project); } @Override @NonNull public List<File> getJavaClassFolders(@NonNull Project project) { return mDelegate.getJavaClassFolders(project); } @NonNull @Override public List<File> getJavaLibraries(@NonNull Project project) { return mDelegate.getJavaLibraries(project); } @Override @NonNull public List<File> getResourceFolders(@NonNull Project project) { return mDelegate.getResourceFolders(project); } @Override @Nullable public XmlParser getXmlParser() { return mDelegate.getXmlParser(); } @Override @NonNull public Class<? extends Detector> replaceDetector(@NonNull Class<? extends Detector> detectorClass) { return mDelegate.replaceDetector(detectorClass); } @Override @NonNull public SdkInfo getSdkInfo(@NonNull Project project) { return mDelegate.getSdkInfo(project); } @Override @NonNull public Project getProject(@NonNull File dir, @NonNull File referenceDir) { return mDelegate.getProject(dir, referenceDir); } @Override public File findResource(@NonNull String relativePath) { return mDelegate.findResource(relativePath); } @Override @Nullable public File getCacheDir(boolean create) { return mDelegate.getCacheDir(create); } @Override @NonNull protected LintClient.ClassPathInfo getClassPath(@NonNull Project project) { return mDelegate.getClassPath(project); } @Override public void log(@Nullable Throwable exception, @Nullable String format, @Nullable Object... args) { mDelegate.log(exception, format, args); } @Override @Nullable public File getSdkHome() { return mDelegate.getSdkHome(); } @Override @NonNull public IAndroidTarget[] getTargets() { return mDelegate.getTargets(); } @Nullable @Override public SdkWrapper getSdk() { return mDelegate.getSdk(); } @Nullable @Override public IAndroidTarget getCompileTarget(@NonNull Project project) { return mDelegate.getCompileTarget(project); } @Override public int getHighestKnownApiLevel() { return mDelegate.getHighestKnownApiLevel(); } @Override @Nullable public String getSuperClass(@NonNull Project project, @NonNull String name) { return mDelegate.getSuperClass(project, name); } @Override @Nullable public Boolean isSubclassOf(@NonNull Project project, @NonNull String name, @NonNull String superClassName) { return mDelegate.isSubclassOf(project, name, superClassName); } @Override @NonNull public String getProjectName(@NonNull Project project) { return mDelegate.getProjectName(project); } @Override public boolean isGradleProject(Project project) { return mDelegate.isGradleProject(project); } @NonNull @Override protected Project createProject(@NonNull File dir, @NonNull File referenceDir) { return mDelegate.createProject(dir, referenceDir); } @NonNull @Override public List<File> findGlobalRuleJars() { return mDelegate.findGlobalRuleJars(); } @NonNull @Override public List<File> findRuleJars(@NonNull Project project) { return mDelegate.findRuleJars(project); } @Override public boolean isProjectDirectory(@NonNull File dir) { return mDelegate.isProjectDirectory(dir); } @Override public void registerProject(@NonNull File dir, @NonNull Project project) { log(Severity.WARNING, null, "Too late to register projects"); mDelegate.registerProject(dir, project); } @Override public IssueRegistry addCustomLintRules(@NonNull IssueRegistry registry) { return mDelegate.addCustomLintRules(registry); } @Override public boolean checkForSuppressComments() { return mDelegate.checkForSuppressComments(); } @Override public boolean supportsProjectResources() { return mDelegate.supportsProjectResources(); } @Nullable @Override public AbstractResourceRepository getProjectResources(Project project, boolean includeDependencies) { return mDelegate.getProjectResources(project, includeDependencies); } @NonNull @Override public Location.Handle createResourceItemHandle(@NonNull ResourceItem item) { return mDelegate.createResourceItemHandle(item); } @Nullable @Override public URLConnection openConnection(@NonNull URL url) throws IOException { return mDelegate.openConnection(url); } @Override public void closeConnection(@NonNull URLConnection connection) throws IOException { mDelegate.closeConnection(connection); } @Override public com.intellij.openapi.project.Project getProject() { return mDelegate.getProject(); } @Override public List<UastLanguagePlugin> getLanguagePlugins() { return mDelegate.getLanguagePlugins(); } } /** * Requests another pass through the data for the given detector. This is * typically done when a detector needs to do more expensive computation, * but it only wants to do this once it <b>knows</b> that an error is * present, or once it knows more specifically what to check for. * * @param detector the detector that should be included in the next pass. * Note that the lint runner may refuse to run more than a couple * of runs. * @param scope the scope to be revisited. This must be a subset of the * current scope ({@link #getScope()}, and it is just a performance hint; * in particular, the detector should be prepared to be called on other * scopes as well (since they may have been requested by other detectors). * You can pall null to indicate "all". */ public void requestRepeat(@NonNull Detector detector, @Nullable EnumSet<Scope> scope) { if (mRepeatingDetectors == null) { mRepeatingDetectors = new ArrayList<Detector>(); } mRepeatingDetectors.add(detector); if (scope != null) { if (mRepeatScope == null) { mRepeatScope = scope; } else { mRepeatScope = EnumSet.copyOf(mRepeatScope); mRepeatScope.addAll(scope); } } else { mRepeatScope = Scope.ALL; } } // Unfortunately, ASMs nodes do not extend a common DOM node type with parent // pointers, so we have to have multiple methods which pass in each type // of node (class, method, field) to be checked. /** * Returns whether the given issue is suppressed in the given method. * * @param issue the issue to be checked, or null to just check for "all" * @param classNode the class containing the issue * @param method the method containing the issue * @param instruction the instruction within the method, if any * @return true if there is a suppress annotation covering the specific * issue on this method */ public boolean isSuppressed(@Nullable Issue issue, @NonNull ClassNode classNode, @NonNull MethodNode method, @Nullable AbstractInsnNode instruction) { if (method.invisibleAnnotations != null) { @SuppressWarnings("unchecked") List<AnnotationNode> annotations = method.invisibleAnnotations; return isSuppressed(issue, annotations); } // Initializations of fields end up placed in generated methods (<init> // for members and <clinit> for static fields). if (instruction != null && method.name.charAt(0) == '<') { AbstractInsnNode next = LintUtils.getNextInstruction(instruction); if (next != null && next.getType() == AbstractInsnNode.FIELD_INSN) { FieldInsnNode fieldRef = (FieldInsnNode) next; FieldNode field = findField(classNode, fieldRef.owner, fieldRef.name); if (field != null && isSuppressed(issue, field)) { return true; } } else if (classNode.outerClass != null && classNode.outerMethod == null && LintUtils.isAnonymousClass(classNode)) { if (isSuppressed(issue, classNode)) { return true; } } } return false; } @Nullable private static MethodInsnNode findConstructorInvocation(@NonNull MethodNode method, @NonNull String className) { InsnList nodes = method.instructions; for (int i = 0, n = nodes.size(); i < n; i++) { AbstractInsnNode instruction = nodes.get(i); if (instruction.getOpcode() == Opcodes.INVOKESPECIAL) { MethodInsnNode call = (MethodInsnNode) instruction; if (className.equals(call.owner)) { return call; } } } return null; } @Nullable private FieldNode findField(@NonNull ClassNode classNode, @NonNull String owner, @NonNull String name) { ClassNode current = classNode; while (current != null) { if (owner.equals(current.name)) { @SuppressWarnings("rawtypes") // ASM API List fieldList = current.fields; for (Object f : fieldList) { FieldNode field = (FieldNode) f; if (field.name.equals(name)) { return field; } } return null; } current = getOuterClassNode(current); } return null; } @Nullable private MethodNode findMethod(@NonNull ClassNode classNode, @NonNull String name, boolean includeInherited) { ClassNode current = classNode; while (current != null) { @SuppressWarnings("rawtypes") // ASM API List methodList = current.methods; for (Object f : methodList) { MethodNode method = (MethodNode) f; if (method.name.equals(name)) { return method; } } if (includeInherited) { current = getOuterClassNode(current); } else { break; } } return null; } /** * Returns whether the given issue is suppressed for the given field. * * @param issue the issue to be checked, or null to just check for "all" * @param field the field potentially annotated with a suppress annotation * @return true if there is a suppress annotation covering the specific * issue on this field */ @SuppressWarnings("MethodMayBeStatic") // API; reserve need to require driver state later public boolean isSuppressed(@Nullable Issue issue, @NonNull FieldNode field) { if (field.invisibleAnnotations != null) { @SuppressWarnings("unchecked") List<AnnotationNode> annotations = field.invisibleAnnotations; return isSuppressed(issue, annotations); } return false; } /** * Returns whether the given issue is suppressed in the given class. * * @param issue the issue to be checked, or null to just check for "all" * @param classNode the class containing the issue * @return true if there is a suppress annotation covering the specific * issue in this class */ public boolean isSuppressed(@Nullable Issue issue, @NonNull ClassNode classNode) { if (classNode.invisibleAnnotations != null) { @SuppressWarnings("unchecked") List<AnnotationNode> annotations = classNode.invisibleAnnotations; return isSuppressed(issue, annotations); } if (classNode.outerClass != null && classNode.outerMethod == null && LintUtils.isAnonymousClass(classNode)) { ClassNode outer = getOuterClassNode(classNode); if (outer != null) { MethodNode m = findMethod(outer, CONSTRUCTOR_NAME, false); if (m != null) { MethodInsnNode call = findConstructorInvocation(m, classNode.name); if (call != null) { if (isSuppressed(issue, outer, m, call)) { return true; } } } m = findMethod(outer, CLASS_CONSTRUCTOR, false); if (m != null) { MethodInsnNode call = findConstructorInvocation(m, classNode.name); if (call != null) { if (isSuppressed(issue, outer, m, call)) { return true; } } } } } return false; } private static boolean isSuppressed(@Nullable Issue issue, List<AnnotationNode> annotations) { for (AnnotationNode annotation : annotations) { String desc = annotation.desc; // We could obey @SuppressWarnings("all") too, but no need to look for it // because that annotation only has source retention. if (desc.endsWith(SUPPRESS_LINT_VMSIG)) { if (annotation.values != null) { for (int i = 0, n = annotation.values.size(); i < n; i += 2) { String key = (String) annotation.values.get(i); if (key.equals("value")) { //$NON-NLS-1$ Object value = annotation.values.get(i + 1); if (value instanceof String) { String id = (String) value; if (matches(issue, id)) { return true; } } else if (value instanceof List) { @SuppressWarnings("rawtypes") List list = (List) value; for (Object v : list) { if (v instanceof String) { String id = (String) v; if (matches(issue, id)) { return true; } } } } } } } } } return false; } private static boolean matches(@Nullable Issue issue, @NonNull String id) { if (id.equalsIgnoreCase(SUPPRESS_ALL)) { return true; } if (issue != null) { String issueId = issue.getId(); if (id.equalsIgnoreCase(issueId)) { return true; } if (id.startsWith(STUDIO_ID_PREFIX) && id.regionMatches(true, STUDIO_ID_PREFIX.length(), issueId, 0, issueId.length()) && id.substring(STUDIO_ID_PREFIX.length()).equalsIgnoreCase(issueId)) { return true; } } return false; } /** * Returns whether the given issue is suppressed in the given parse tree node. * * @param context the context for the source being scanned * @param issue the issue to be checked, or null to just check for "all" * @param scope the AST node containing the issue * @return true if there is a suppress annotation covering the specific * issue in this class */ public boolean isSuppressed(@Nullable JavaContext context, @NonNull Issue issue, @Nullable UElement scope) { boolean checkComments = mClient.checkForSuppressComments() && context != null && context.containsCommentSuppress(); while (scope != null) { if (scope instanceof UVariable) { UVariable declaration = (UVariable) scope; if (isUastSuppressed(issue, declaration.getAnnotations())) { return true; } } else if (scope instanceof UFunction) { UFunction declaration = (UFunction) scope; if (isUastSuppressed(issue, declaration.getAnnotations())) { return true; } } else if (scope instanceof UClass) { UClass declaration = (UClass) scope; if (isUastSuppressed(issue, declaration.getAnnotations())) { return true; } } //TODO check comments //if (checkComments && context.isSuppressedWithComment(scope, issue)) { // return true; //} scope = scope.getParent(); } return false; } /** * Returns true if the given AST modifier has a suppress annotation for the * given issue (which can be null to check for the "all" annotation) * * @param issue the issue to be checked * @param modifiers the modifier to check * @return true if the issue or all issues should be suppressed for this * modifier */ private static boolean isUastSuppressed(@Nullable Issue issue, @Nullable List<UAnnotation> annotations) { for (UAnnotation annotation : annotations) { if (annotation.matchesName(SUPPRESS_LINT) || annotation.matchesName("SuppressWarnings")) { //$NON-NLS-1$ List<UNamedExpression> values = annotation.getValueArguments(); for (UNamedExpression element : values) { UExpression valueNode = element.getExpression(); String value = UastLiteralUtils.getValueIfStringLiteral(valueNode); if (value != null) { if (matches(issue, value)) { return true; } } else if (valueNode instanceof UCallExpression && ((UCallExpression) valueNode).getKind() == UastCallKind.ARRAY_INITIALIZER) { UCallExpression array = (UCallExpression) valueNode; List<UExpression> expressions = array.getValueArguments(); for (UExpression arrayElement : expressions) { String elementValue = UastLiteralUtils.getValueIfStringLiteral(arrayElement); if (elementValue != null) { if (matches(issue, elementValue)) { return true; } } } } } } } return false; } /** * Returns whether the given issue is suppressed in the given XML DOM node. * * @param issue the issue to be checked, or null to just check for "all" * @param node the DOM node containing the issue * @return true if there is a suppress annotation covering the specific * issue in this class */ public boolean isSuppressed(@Nullable XmlContext context, @NonNull Issue issue, @Nullable org.w3c.dom.Node node) { if (node instanceof Attr) { node = ((Attr) node).getOwnerElement(); } boolean checkComments = mClient.checkForSuppressComments() && context != null && context.containsCommentSuppress(); while (node != null) { if (node.getNodeType() == org.w3c.dom.Node.ELEMENT_NODE) { Element element = (Element) node; if (element.hasAttributeNS(TOOLS_URI, ATTR_IGNORE)) { String ignore = element.getAttributeNS(TOOLS_URI, ATTR_IGNORE); if (ignore.indexOf(',') == -1) { if (matches(issue, ignore)) { return true; } } else { for (String id : ignore.split(",")) { //$NON-NLS-1$ if (matches(issue, id)) { return true; } } } } else if (checkComments && context.isSuppressedWithComment(node, issue)) { return true; } } node = node.getParentNode(); } return false; } private File mCachedFolder = null; private int mCachedFolderVersion = -1; /** Pattern for version qualifiers */ private static final Pattern VERSION_PATTERN = Pattern.compile("^v(\\d+)$"); //$NON-NLS-1$ /** * Returns the folder version of the given file. For example, for the file values-v14/foo.xml, * it returns 14. * * @param resourceFile the file to be checked * @return the folder version, or -1 if no specific version was specified */ public int getResourceFolderVersion(@NonNull File resourceFile) { File parent = resourceFile.getParentFile(); if (parent == null) { return -1; } if (parent.equals(mCachedFolder)) { return mCachedFolderVersion; } mCachedFolder = parent; mCachedFolderVersion = -1; for (String qualifier : QUALIFIER_SPLITTER.split(parent.getName())) { Matcher matcher = VERSION_PATTERN.matcher(qualifier); if (matcher.matches()) { String group = matcher.group(1); assert group != null; mCachedFolderVersion = Integer.parseInt(group); break; } } return mCachedFolderVersion; } }