import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
private static NewRule addAnnotatedRule(NewRepository repository, Class<?> ruleClass) {
  org.sonar.check.Rule ruleAnnotation = AnnotationUtils.getAnnotation(ruleClass, org.sonar.check.Rule.class);
  if (ruleAnnotation == null) {
    throw new IllegalStateException("No Rule annotation was found on " + ruleClass.getName());
  }
  String ruleKey = ruleAnnotation.key();
  if (ruleKey.length() == 0) {
    throw new IllegalStateException("Empty key");
  }
  new RulesDefinitionAnnotationLoader().load(repository, ruleClass);
  NewRule rule = repository.rule(ruleKey);
  if (rule == null) {
    throw new IllegalStateException("Rule not found: " + ruleKey);
  }
  return rule;
}
 

import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
@VisibleForTesting
protected void newRule(Class<?> ruleClass, NewRepository repository) {

  org.sonar.check.Rule ruleAnnotation = AnnotationUtils.getAnnotation(ruleClass, org.sonar.check.Rule.class);
  if (ruleAnnotation == null) {
    throw new IllegalArgumentException("No Rule annotation was found on " + ruleClass);
  }
  String ruleKey = ruleAnnotation.key();
  if (StringUtils.isEmpty(ruleKey)) {
    throw new IllegalArgumentException("No key is defined in Rule annotation of " + ruleClass);
  }
  NewRule rule = repository.rule(ruleKey);
  if (rule == null) {
    throw new IllegalStateException("No rule was created for " + ruleClass + " in " + repository.key());
  }
  ruleMetadata(ruleClass, rule);

  rule.setTemplate(AnnotationUtils.getAnnotation(ruleClass, RuleTemplate.class) != null);
  if (ruleAnnotation.cardinality() == Cardinality.MULTIPLE) {
    throw new IllegalArgumentException("Cardinality is not supported, use the RuleTemplate annotation instead for " + ruleClass);
  }
}
 

import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
/**
 * Loads HTML descriptions and meta data from JSON file to checks.
 *
 * @param ruleClass Class type of given rule.
 * @param repository current repository.
 */
@VisibleForTesting
protected void newRule(Class<?> ruleClass, NewRepository repository) {
    org.sonar.check.Rule ruleAnnotation = AnnotationUtils.getAnnotation(ruleClass, org.sonar.check.Rule.class);
    if (ruleAnnotation == null) {
        throw new IllegalArgumentException(
                String.format("No Rule annotation was found on %s", ruleClass));
    }
    String ruleKey = ruleAnnotation.key();
    if (StringUtils.isEmpty(ruleKey)) {
        throw new IllegalArgumentException(
                String.format("No key is defined in Rule annotation of %s", ruleClass));
    }
    NewRule rule = repository.rule(ruleKey);
    if (rule == null) {
        throw new IllegalStateException(
                String.format("No rule was created for %s in %s", ruleClass, repository.key()));
    }
    addHtmlDescription(rule, rule.key());
    addMetadata(rule, rule.key());
}
 

import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
public void addIssue(@Nullable Integer line, CodeCheck check, String message, @Nullable Double cost) {
  Preconditions.checkNotNull(check);
  Preconditions.checkNotNull(message);
  CheckMessage checkMessage = new CheckMessage(check, message);
  if (line > 0) {
    checkMessage.setLine(line);
  }
  if (cost == null) {
    Annotation linear = AnnotationUtils.getAnnotation(check, SqaleLinearRemediation.class);
    Annotation linearWithOffset = AnnotationUtils.getAnnotation(check, SqaleLinearWithOffsetRemediation.class);
    if (linear != null || linearWithOffset != null) {
      throw new IllegalStateException("A check annotated with a linear SQALE function should provide an effort to fix.");
    }
  } else {
    checkMessage.setCost(cost);
  }

  if (getContext().peekSourceCode() instanceof SourceFile) {
    getContext().peekSourceCode().log(checkMessage);
  } else if (getContext().peekSourceCode().getParent(SourceFile.class) != null) {
    getContext().peekSourceCode().getParent(SourceFile.class).log(checkMessage);
  } else {
    throw new IllegalStateException("Unable to log a check message on source code '"
      + (getContext().peekSourceCode() == null ? "[NULL]" : getContext().peekSourceCode().getKey()) + "'");
  }
}
 

import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
private static Phase.Name evaluatePhase(Object extension) {
  Object extensionToEvaluate;
  if (extension instanceof SensorWrapper) {
    extensionToEvaluate = ((SensorWrapper) extension).wrappedSensor();
  } else {
    extensionToEvaluate = extension;
  }
  Phase phaseAnnotation = AnnotationUtils.getAnnotation(extensionToEvaluate, Phase.class);
  if (phaseAnnotation != null) {
    return phaseAnnotation.name();
  }
  return Phase.Name.DEFAULT;
}
 

import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
public static boolean isInstantiationStrategy(Object extension, String strategy) {
  InstantiationStrategy annotation = AnnotationUtils.getAnnotation(extension, InstantiationStrategy.class);
  if (annotation != null) {
    return strategy.equals(annotation.value());
  }
  return InstantiationStrategy.PER_PROJECT.equals(strategy);
}
 

import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
private String ruleMetadata(Class<?> ruleClass, NewRule rule) {
  String metadataKey = rule.key();
  org.sonar.java.RspecKey rspecKeyAnnotation = AnnotationUtils.getAnnotation(ruleClass, org.sonar.java.RspecKey.class);
  if (rspecKeyAnnotation != null) {
    metadataKey = rspecKeyAnnotation.value();
    rule.setInternalKey(metadataKey);
  }
  addHtmlDescription(rule, metadataKey);
  addMetadata(rule, metadataKey);
  return metadataKey;
}
 

import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
@Override
public List<Rule> createRules() {
  List<Rule> result = Lists.newArrayList();
  for (Class ruleClass : TanaguruCheckClasses.getCheckClasses()) {
    if (AnnotationUtils.getAnnotation(ruleClass, WebRule.class) != null) {
      result.add(RuleRepositoryHelper.createRule(
        REPOSITORY_KEY,
        ruleClass,
        AnnotationUtils.getAnnotation(ruleClass, org.sonar.check.Rule.class),
        AnnotationUtils.getAnnotation(ruleClass, TanaguruRuleTags.class)
      ));
    }
  }
  return result;
}
 

import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
@CheckForNull
RulesDefinition.NewRule loadRule(RulesDefinition.NewExtendedRepository repo, Class<? extends JavaCheck> clazz) {
	Rule ruleAnnotation = AnnotationUtils.getAnnotation(clazz, Rule.class);
	if (ruleAnnotation != null) {
		return loadRule(repo, clazz, ruleAnnotation);
	} else {
		LOG.warn("The class {} should be annotated with {}", clazz.getCanonicalName(), Rule.class);
		return null;
	}
}
 

import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
private static Class<AbstractCheck> getCheckClass(Rule rule) {
    for (Class<?> checkClass : CheckClasses.getChecks()) {

        org.sonar.check.Rule ruleAnnotation = AnnotationUtils.getClassAnnotation(checkClass, org.sonar.check.Rule.class);
        if (ruleAnnotation.key().equals(rule.getConfigKey())) {
            return (Class<AbstractCheck>) checkClass;
        }
    }
    System.out.println("Could not find check class for config key " + rule.getConfigKey());
    return null;
}
 

import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static Class<BeanCheck> getCheckClass(final ActiveRule activeRule) {
    for (Class<?> checkClass : CheckClasses.getCheckClasses()) {

        org.sonar.check.Rule ruleAnnotation = AnnotationUtils.getClassAnnotation(checkClass, org.sonar.check.Rule.class);
        if (ruleAnnotation.key().equals(activeRule.getConfigKey())) {
            return (Class<BeanCheck>) checkClass;
        }
    }
    LOGGER.error("Could not find check class for config key " + activeRule.getConfigKey());
    return null;
}
 

import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
public static boolean isSonarLintSide(Object extension) {
  return AnnotationUtils.getAnnotation(extension, SonarLintSide.class) != null;
}
 

import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
public static boolean isScannerSide(Object extension) {
  return AnnotationUtils.getAnnotation(extension, BatchSide.class) != null ||
    AnnotationUtils.getAnnotation(extension, ScannerSide.class) != null ||
    AnnotationUtils.getAnnotation(extension, SonarLintSide.class) != null;
}
 

import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
@Override
protected boolean isTagIncluded(Class ruleClass) {
  TanaguruRuleTags ruleAnnotation = AnnotationUtils.getAnnotation(ruleClass, TanaguruRuleTags.class);
  return Arrays.asList(ruleAnnotation.value()).contains(TanaguruRuleTags.RGAA3);
}
 

import org.sonar.api.utils.AnnotationUtils; //导入依赖的package包/类
protected boolean isActive(Class ruleClass) {
  WebRule ruleAnnotation = AnnotationUtils.getAnnotation(ruleClass, WebRule.class);
  return ruleAnnotation != null && ruleAnnotation.activeByDefault() && isTagIncluded(ruleClass);
}