import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
@Override
public boolean visitAnnotation(Annotation node) {
  String type = node.astAnnotationTypeReference().getTypeName();
  if (DAGGER_MODULE.equals(type)) {
    Node parent = node.getParent();
    if (parent instanceof Modifiers) {
      parent = parent.getParent();
      if (parent instanceof ClassDeclaration) {
        int flags = ((ClassDeclaration) parent).astModifiers().getEffectiveModifierFlags();
        if ((flags & Modifier.ABSTRACT) == 0) {
          context.report(ISSUE, Location.create(context.file), ISSUE.getBriefDescription(TextFormat.TEXT));
        }
      }
    }
  }

  return super.visitAnnotation(node);
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
/**
 * Given an error message produced by this lint detector,
 * returns the old value to be replaced in the source code.
 * <p>
 * Intended for IDE quickfix implementations.
 *
 * @param errorMessage the error message associated with the error
 * @param format the format of the error message
 * @return the corresponding old value, or null if not recognized
 */
@Nullable
public static String getOldValue(@NonNull String errorMessage,
        @NonNull TextFormat format) {
    errorMessage = format.toText(errorMessage);
    String attribute = LintUtils.findSubstring(errorMessage, " should use ", " ");
    if (attribute == null) {
        attribute = LintUtils.findSubstring(errorMessage, " should use ", null);
    }
    if (attribute != null) {
        int index = attribute.indexOf(':');
        if (index != -1) {
            return ANDROID_NS_NAME + attribute.substring(index);
        }
    }

    return null;
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
@Override
public boolean visitCallExpression(UCallExpression node) {
    if (!METHOD_NAME.equals(node.getMethodName())) return false;

    final JavaUCompositeQualifiedExpression exp =
            (JavaUCompositeQualifiedExpression) node.getUastParent();
    if (exp == null
            || !CLASS_SQLITE_OPERATOR.equals(exp.receiver.toString())
            || node.getValueArgumentCount() != 2) return false;

    final JavaUClassLiteralExpression classLiteral =
            (JavaUClassLiteralExpression) node.getValueArguments().get(PARAM_INDEX);

    if (classLiteral == null) return false;

    final PsiClass psiClass = mContext.getEvaluator().findClass(classLiteral.toString());

    if (psiClass == null
            || psiClass.getModifierList() == null) return false;

    boolean found = false;
    for (final PsiAnnotation annotation : psiClass.getModifierList().getAnnotations()) {
        if (!ANNOTATION_TYPE_LONG.equals(annotation.getQualifiedName())) continue;

        found = true;
        break;
    }

    if (!found) {
        mContext.report(ISSUE, mContext.getLocation(classLiteral),
                String.format(ISSUE.getExplanation(TextFormat.TEXT), classLiteral));
        return true;
    }

    return false;
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
@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);
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
private void formatError(String message, Object... args) {
    if (args != null && args.length > 0) {
        message = String.format(message, args);
    }
    message = "Failed to parse `lint.xml` configuration file: " + message;
    LintDriver driver = new LintDriver(new IssueRegistry() {
        @Override @NonNull public List<Issue> getIssues() {
            return Collections.emptyList();
        }
    }, mClient);
    mClient.report(new Context(driver, mProject, mProject, mConfigFile),
            IssueRegistry.LINT_ERROR,
            mProject.getConfiguration().getSeverity(IssueRegistry.LINT_ERROR),
            Location.create(mConfigFile), message, TextFormat.RAW);
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
public static int getRequiredVersion(@NonNull Issue issue, @NonNull String errorMessage,
        @NonNull TextFormat format) {
    errorMessage = format.toText(errorMessage);

    if (issue == UNSUPPORTED || issue == INLINED) {
        Pattern pattern = Pattern.compile("\\s(\\d+)\\s"); //$NON-NLS-1$
        Matcher matcher = pattern.matcher(errorMessage);
        if (matcher.find()) {
            return Integer.parseInt(matcher.group(1));
        }
    }

    return -1;
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
/** Returns the suggested replacements, if any, for the given typo. The error
 * message <b>must</b> be one supplied by lint.
 *
 * @param errorMessage the error message
 * @param format the format of the error message
 * @return a list of replacement words suggested by the error message
 */
@Nullable
public static List<String> getSuggestions(@NonNull String errorMessage,
        @NonNull TextFormat format) {
    errorMessage = format.toText(errorMessage);

    // The words are all in quotes; the first word is the misspelling,
    // the other words are the suggested replacements
    List<String> words = new ArrayList<String>();
    // Skip the typo
    int index = errorMessage.indexOf('"');
    index = errorMessage.indexOf('"', index + 1);
    index++;

    while (true) {
        index = errorMessage.indexOf('"', index);
        if (index == -1) {
            break;
        }
        index++;
        int start = index;
        index = errorMessage.indexOf('"', index);
        if (index == -1) {
            index = errorMessage.length();
        }
        words.add(errorMessage.substring(start, index));
        index++;
    }

    return words;
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
/**
 * Returns the typo word in the error message from this detector
 *
 * @param errorMessage the error message produced earlier by this detector
 * @param format the format of the error message
 * @return the typo
 */
@Nullable
public static String getTypo(@NonNull String errorMessage, @NonNull TextFormat format) {
    errorMessage = format.toText(errorMessage);
    // The words are all in quotes
    int index = errorMessage.indexOf('"');
    int start = index + 1;
    index = errorMessage.indexOf('"', start);
    if (index != -1) {
        return errorMessage.substring(start, index);
    }

    return null;
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
/**
 * Given an error message produced by this lint detector for the given issue type,
 * returns the old value to be replaced in the source code.
 * <p>
 * Intended for IDE quickfix implementations.
 *
 * @param issue the corresponding issue
 * @param errorMessage the error message associated with the error
 * @param format the format of the error message
 * @return the corresponding old value, or null if not recognized
 */
@Nullable
public static String getOldValue(@NonNull Issue issue, @NonNull String errorMessage,
        @NonNull TextFormat format) {
    errorMessage = format.toText(errorMessage);

    // Consider extracting all the error strings as constants and handling this
    // using the LintUtils#getFormattedParameters() method to pull back out the information
    if (issue == DEPENDENCY) {
        // "A newer version of com.google.guava:guava than 11.0.2 is available: 17.0.0"
        if (errorMessage.startsWith("A newer ")) {
            return findSubstring(errorMessage, " than ", " ");
        }
        if (errorMessage.startsWith("Old buildToolsVersion ")) {
            return findSubstring(errorMessage, "Old buildToolsVersion ", ";");
        }
        // "The targetSdkVersion (20) should not be higher than the compileSdkVersion (19)"
        return findSubstring(errorMessage, "targetSdkVersion (", ")");
    } else if (issue == STRING_INTEGER) {
        return findSubstring(errorMessage, "replace ", " with ");
    } else if (issue == DEPRECATED) {
        if (errorMessage.contains(GradleDetector.APP_PLUGIN_ID) &&
                errorMessage.contains(GradleDetector.OLD_APP_PLUGIN_ID)) {
            return GradleDetector.OLD_APP_PLUGIN_ID;
        } else if (errorMessage.contains(GradleDetector.LIB_PLUGIN_ID) &&
                errorMessage.contains(GradleDetector.OLD_LIB_PLUGIN_ID)) {
            return GradleDetector.OLD_LIB_PLUGIN_ID;
        }
        // "Deprecated: Replace 'packageNameSuffix' with 'applicationIdSuffix'"
        return findSubstring(errorMessage, "Replace '", "'");
    } else if (issue == PLUS) {
      return findSubstring(errorMessage, "(", ")");
    } else if (issue == COMPATIBILITY) {
        if (errorMessage.startsWith("Version 5.2.08")) {
            return "5.2.08";
        }
    }

    return null;
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
/**
 * Given an error message produced by this lint detector for the given issue type,
 * returns the new value to be put into the source code.
 * <p>
 * Intended for IDE quickfix implementations.
 *
 * @param issue the corresponding issue
 * @param errorMessage the error message associated with the error
 * @param format the format of the error message
 * @return the corresponding new value, or null if not recognized
 */
@Nullable
public static String getNewValue(@NonNull Issue issue, @NonNull String errorMessage,
        @NonNull TextFormat format) {
    errorMessage = format.toText(errorMessage);

    if (issue == DEPENDENCY) {
        // "A newer version of com.google.guava:guava than 11.0.2 is available: 17.0.0"
        if (errorMessage.startsWith("A newer ")) {
            return findSubstring(errorMessage, " is available: ", null);
        }
        if (errorMessage.startsWith("Old buildToolsVersion ")) {
            return findSubstring(errorMessage, " version is ", " ");
        }
        // "The targetSdkVersion (20) should not be higher than the compileSdkVersion (19)"
        return findSubstring(errorMessage, "compileSdkVersion (", ")");
    } else if (issue == STRING_INTEGER) {
        return findSubstring(errorMessage, " just ", ")");
    } else if (issue == DEPRECATED) {
        if (errorMessage.contains(GradleDetector.APP_PLUGIN_ID) &&
                errorMessage.contains(GradleDetector.OLD_APP_PLUGIN_ID)) {
            return GradleDetector.APP_PLUGIN_ID;
        } else if (errorMessage.contains(GradleDetector.LIB_PLUGIN_ID) &&
                errorMessage.contains(GradleDetector.OLD_LIB_PLUGIN_ID)) {
            return GradleDetector.LIB_PLUGIN_ID;
        }
        // "Deprecated: Replace 'packageNameSuffix' with 'applicationIdSuffix'"
        return findSubstring(errorMessage, " with '", "'");
    } else if (issue == COMPATIBILITY) {
        if (errorMessage.startsWith("Version 5.2.08")) {
            return findSubstring(errorMessage, "Use version ", " ");
        }
    }

    return null;
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
/**
 * Given an error message produced by this lint detector,
 * returns the new value to be put into the source code.
 * <p>
 * Intended for IDE quickfix implementations.
 *
 * @param errorMessage the error message associated with the error
 * @param format the format of the error message
 * @return the corresponding new value, or null if not recognized
 */
@Nullable
public static String getNewValue(@NonNull String errorMessage,
        @NonNull TextFormat format) {
    errorMessage = format.toText(errorMessage);
    String attribute = LintUtils.findSubstring(errorMessage, " should use ", " ");
    if (attribute == null) {
        attribute = LintUtils.findSubstring(errorMessage, " should use ", null);
    }
    return attribute;
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
/**
 * For an error message for an {@link #USE_VALUE_OF} issue reported by this detector,
 * returns the type being replaced. Intended to use for IDE quickfix implementations.
 */
@Nullable
public static String getReplacedType(@NonNull String message, @NonNull TextFormat format) {
    message = format.toText(message);
    int index = message.indexOf('.');
    if (index != -1 && message.startsWith("Use ")) {
        return message.substring(4, index);
    }
    return null;
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
@Nullable
private static String getMessagePart(@NonNull String errorMessage, int group,
        @NonNull TextFormat format) {
    List<String> parameters = LintUtils.getFormattedParameters(
            RAW.convertTo(ERROR_MESSAGE_FORMAT, format),
            errorMessage);
    if (parameters.size() == 2 && group <= 2) {
        return parameters.get(group - 1);
    }

    return null;
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
private void explainIssue(@NonNull StringBuilder output, @Nullable Issue issue)
        throws IOException {
    if (issue == null || !mFlags.isExplainIssues() || issue == IssueRegistry.LINT_ERROR) {
        return;
    }

    String explanation = issue.getExplanation(TextFormat.TEXT);
    if (explanation.trim().isEmpty()) {
        return;
    }

    String indent = "   ";
    String formatted = SdkUtils.wrap(explanation, Main.MAX_LINE_WIDTH - indent.length(), null);
    output.append('\n');
    output.append(indent);
    output.append("Explanation for issues of type \"").append(issue.getId()).append("\":\n");
    for (String line : Splitter.on('\n').split(formatted)) {
        if (!line.isEmpty()) {
            output.append(indent);
            output.append(line);
        }
        output.append('\n');
    }
    List<String> moreInfo = issue.getMoreInfo();
    if (!moreInfo.isEmpty()) {
        for (String url : moreInfo) {
            if (formatted.contains(url)) {
                continue;
            }
            output.append(indent);
            output.append(url);
            output.append('\n');
        }
        output.append('\n');
    }
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
protected void reportNonExistingIssueId(@Nullable Project project, @NonNull String id) {
    String message = String.format("Unknown issue id \"%1$s\"", id);

    if (mDriver != null && project != null) {
        Location location = Location.create(project.getDir());
        if (!isSuppressed(IssueRegistry.LINT_ERROR)) {
            report(new Context(mDriver, project, project, project.getDir()),
                    IssueRegistry.LINT_ERROR,
                    project.getConfiguration().getSeverity(IssueRegistry.LINT_ERROR),
                    location, message, TextFormat.RAW);
        }
    } else {
        log(Severity.ERROR, null, "Lint: %1$s", message);
    }
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
private void writeSuppressInfo() throws IOException {
    //getSuppressHelp
    mWriter.write("\n<a name=\"SuppressInfo\"></a>\n");      //$NON-NLS-1$
    mWriter.write("<div class=\"category\">");               //$NON-NLS-1$
    mWriter.write("Suppressing Warnings and Errors");
    mWriter.write("<div class=\"categorySeparator\"></div>\n");//$NON-NLS-1$
    mWriter.write("</div>\n");                               //$NON-NLS-1$
    mWriter.write(TextFormat.RAW.convertTo(Main.getSuppressHelp(), TextFormat.HTML));
    mWriter.write('\n');
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
@Override
public void report(
        @NonNull Context context,
        @NonNull Issue issue,
        @NonNull Severity severity,
        @Nullable Location location,
        @NonNull String message,
        @NonNull TextFormat format) {
    System.out.println(location + ":" + message);
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
@Override
public String getDescription(@NotNull final String refSuffix, @NotNull final Editor editor) {
  final Project project = editor.getProject();
  if (project == null) {
    LOG.error(editor);
    return null;
  }

  final PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
  if (file == null) {
    return null;
  }

  Issue issue = new BuiltinIssueRegistry().getIssue(refSuffix);
  if (issue != null) {
    String html = issue.getExplanation(TextFormat.HTML);
    // IntelliJ seems to treat newlines in the HTML as needing to also be converted to <br> (whereas
    // Lint includes these for HTML readability but they shouldn't add additional lines since it has
    // already added <br> as well) so strip these out
    html = html.replace("\n", "");
    return html;
  }

  // TODO: What about custom registries for custom rules, AARs etc?

  LOG.warn("No description for inspection '" + refSuffix + "'");
  return InspectionsBundle.message("inspection.tool.description.under.construction.text");
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
String error(String name, Issue issue) {
  return String.format("%s: Error: %s [%s]\n1 errors, 0 warnings\n", name, issue.getBriefDescription(TextFormat.TEXT), issue.getId());
}
 

import com.android.tools.lint.detector.api.TextFormat; //导入依赖的package包/类
/**
 * All param should be non-null.
 */
void reportIssue(JavaContext context, Issue issue, PsiElement element) {
    context.report(issue, element, context.getLocation(element),
            issue.getBriefDescription(TextFormat.TEXT));
}