import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
private void buildGraph(Tree tree) {
  String label = tree.kind() + (tree.firstToken() != null ? (" L#" + tree.firstToken().line()) : "");
  addNode(new ASTDotNode(index, label, tree.kind()));
  if (tree.is(Tree.Kind.TOKEN)) {
    // add an extra node for tokens
    addNode(new ASTDotNode(index, escapeSpecialChars(((SyntaxToken) tree).text())));
  }
  int currentNodeIndex = index;
  if (!((JavaTree) tree).isLeaf()) {
    for (Tree child : ((JavaTree) tree).getChildren()) {
      index++;
      int childIndex = index;
      buildGraph(child);
      addEdge(new ASTDotEdge(currentNodeIndex, childIndex));
    }
  }
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
@Override
public void visitMethod(MethodTree tree) {
  if (implementsSpecificInterface) {
    List<AnnotationTree> annotations = tree.modifiers().annotations();

    boolean isHavingMandatoryAnnotation = Boolean.FALSE;

    for (AnnotationTree annotationTree : annotations) {
      if (annotationTree.annotationType().is(Tree.Kind.IDENTIFIER)) {
        IdentifierTree idf = (IdentifierTree) annotationTree.annotationType();
        LOGGER.info("Method Name {}", idf.name());

        if (idf.name().equals(name)) {
          isHavingMandatoryAnnotation = Boolean.TRUE;
        }
      }
    }
    if (!isHavingMandatoryAnnotation) {
      context.reportIssue(this, tree, String.format("Mandatory Annotation not set @%s", name));
    }

  }
  // The call to the super implementation allows to continue the visit of the AST.
  // Be careful to always call this method to visit every node of the tree.
  super.visitMethod(tree);
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
@Override
public void visitNode(Tree tree) {
  // Cast the node to the correct type :
  // in this case we registered only to one kind so we will only receive MethodTree see Tree.Kind enum to know about which type you can
  // cast depending on Kind.
  MethodTree methodTree = (MethodTree) tree;
  // Retrieve symbol of method.
  MethodSymbol methodSymbol = methodTree.symbol();
  Type returnType = methodSymbol.returnType().type();
  // Check method has only one argument.
  if (methodSymbol.parameterTypes().size() == 1) {
    Type argType = methodSymbol.parameterTypes().get(0);
    // Verify argument type is same as return type.
    if (argType.is(returnType.fullyQualifiedName())) {
      // raise an issue on this node of the SyntaxTree
      reportIssue(tree, "message");
    }
  }
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
@Override
public void visitNode(Tree tree) {
  // Visit CLASS node only => cast could be done
  ClassTree treeClazz = (ClassTree) tree;

  // No extends => stop to visit class
  if (treeClazz.superClass() == null) {
    return;
  }

  // For 'symbolType' usage, jar in dependencies must be on classpath, !unknownSymbol! result otherwise
  String superClassName = treeClazz.superClass().symbolType().fullyQualifiedName();

  // Check if superClass avoid
  if (SUPER_CLASS_AVOID.contains(superClassName)) {
    reportIssue(tree, String.format("The usage of super class %s is forbidden", superClassName));
  }
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
@Override
public void visitMethod(MethodTree tree) {
  List<AnnotationTree> annotations = tree.modifiers().annotations();
  for (AnnotationTree annotationTree : annotations) {
    if (annotationTree.annotationType().is(Tree.Kind.IDENTIFIER)) {
      IdentifierTree idf = (IdentifierTree) annotationTree.annotationType();
      System.out.println(idf.name());

      if (idf.name().equals(name)) {
        context.reportIssue(this, idf, String.format("Avoid using annotation @%s", name));
      }
    }
  }

  // The call to the super implementation allows to continue the visit of the AST.
  // Be careful to always call this method to visit every node of the tree.
  super.visitMethod(tree);
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
protected boolean checkIfLongSession(MethodTree method) {
	List<AnnotationTree> annotations = method.modifiers().annotations();
	for (AnnotationTree annotationTree : annotations) {
		if (annotationTree.annotationType().is(Tree.Kind.IDENTIFIER)) {
			IdentifierTree idf = (IdentifierTree) annotationTree.annotationType();
			if (idf.name().equals(ACTIVATE)) {
				collectLongSessionOpened(method);
				return true;
			}
			else if (idf.name().equals(DEACTIVATE)) {
				collectLongSessionClosed(method);
				return true;
			}
		}
	}
	return false;
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
protected boolean checkIfLongResourceResolver(MethodTree method) {
	List<AnnotationTree> annotations = method.modifiers().annotations();
	for (AnnotationTree annotationTree : annotations) {
		if (annotationTree.annotationType().is(Tree.Kind.IDENTIFIER)) {
			IdentifierTree idf = (IdentifierTree) annotationTree.annotationType();
			if (idf.name().equals(ACTIVATE)) {
				collectLongResourceResolverOpened(method);
				return true;
			}
			else if (idf.name().equals(DEACTIVATE)) {
				collectLongResourceResolverClosed(method);
				return true;
			}
		}
	}
	return false;
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
private static void appendElements(StringBuilder buffer, CFG.Block block) {
  int i = 0;
  for (Tree tree : block.elements()) {
    buffer.append('\n');
    buffer.append(i);
    buffer.append(":\t");
    appendKind(buffer, tree.kind());
    buffer.append(toString(tree));
    i++;
  }
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
private static void appendTerminator(StringBuilder buffer, CFG.Block block) {
  Tree terminator = block.terminator();
  if (terminator != null) {
    buffer.append("\nT:\t");
    appendKind(buffer, terminator.kind());
    buffer.append(toString(terminator));
  }
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
private static String toString(Tree tree) {
  Stream.Builder<String> sb = Stream.builder();
  switch (tree.kind()) {
    case TOKEN:
      sb.add(((SyntaxToken) tree).text());
      break;
    case VARIABLE:
      VariableTree vt = (VariableTree) tree;
      // skip initializer
      addTrees(sb, vt.type(), vt.simpleName());
      break;
    case NEW_CLASS:
      NewClassTree nct = (NewClassTree) tree;
      // skip body for anonymous classes
      addTrees(sb, nct.newKeyword(), nct.identifier(), nct.arguments());
      break;
    case MEMBER_SELECT:
      MemberSelectExpressionTree mset = (MemberSelectExpressionTree) tree;
      if (mset.expression().is(Tree.Kind.METHOD_INVOCATION)) {
        // skip method invocation
        addTrees(sb, mset.identifier());
      } else {
        addChildren(sb, tree);
      }
      break;
    case IF_STATEMENT:
      IfStatementTree ist = (IfStatementTree) tree;
      // skip thenClause and elseClause
      addTrees(sb, ist.ifKeyword(), ist.openParenToken(), ist.condition(), ist.closeParenToken());
      break;
    default:
      addChildren(sb, tree);
      break;
  }
  return sb.build().filter(text -> !text.isEmpty()).collect(Collectors.joining(" "));
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
private static void addChildren(Stream.Builder<String> sb, Tree tree) {
  if (tree.is(Tree.Kind.INFERED_TYPE)) {
    // do nothing, infered types does not have children
    return;
  }
  addTrees(sb, ((JavaTree) tree).getChildren());
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
private String programPoint() {
  String tree = "";
  if (pp.i < pp.block.elements().size()) {
    Tree syntaxNode = ((CFG.Block) pp.block).elements().get(pp.i);
    tree = "" + syntaxNode.kind() + " L#" + syntaxNode.firstToken().line();
  }
  return programPointKey() + "  " + tree;
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
@CheckForNull
private static MethodBehavior getMethodBehavior(BehaviorCache bc, @Nullable Tree syntaxTree) {
  if (syntaxTree == null || !syntaxTree.is(Tree.Kind.METHOD_INVOCATION)) {
    return null;
  }
  Symbol symbol = ((MethodInvocationTree) syntaxTree).symbol();
  if (!symbol.isMethodSymbol()) {
    return null;
  }
  return bc.get((Symbol.MethodSymbol) symbol);
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
@CheckForNull
private static MethodTree getFirstMethodOrConstructor(CompilationUnitTree cut) {
  return (MethodTree) cut.types().stream()
    .findFirst()
    .map(ClassTree.class::cast)
    .map(ClassTree::members)
    .map(List::stream)
    .flatMap(members -> members.filter(m -> m.is(Tree.Kind.METHOD, Tree.Kind.CONSTRUCTOR)).findFirst())
    .orElse(null);
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
@Override
public void visitNode(Tree tree) {

  if (((NewClassTree) tree).symbolType().isSubtypeOf("org.apache.commons.collections4.list.UnmodifiableList")) {
    reportIssue(tree, "Avoid using UnmodifiableList");
  }
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
@Override
protected void scan(List<? extends Tree> trees) {
  if (!trees.isEmpty()) {
    sb.deleteCharAt(sb.length() - 1);
    sb.append(" : [\n");
    super.scan(trees);
    indent().append("]\n");
  }
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
@Override
public void visitReturnStatement(ReturnStatementTree tree) {
	if (tree.expression() != null && tree.expression().is(Kind.IDENTIFIER)) {
		IdentifierTree identifier = (IdentifierTree) tree.expression();
		Tree declaration = getDeclaration(identifier);
		if (sessions.contains(declaration)) {
			sessions.remove(declaration);
		}
	}
	super.visitReturnStatement(tree);
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
@Override
public void visitMethodInvocation(MethodInvocationTree tree) {
	Tree declaration = tree.symbol().declaration();
	if (null != declaration) {
		declaration.accept(new MethodInvocationVisitor(javaFileScanner, context));
	}
	super.visitMethodInvocation(tree);
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
@Override
public void visitParameterizedType(ParameterizedTypeTree parameterizedTypeTree) {
	for (Iterator<Tree> iterator = parameterizedTypeTree.typeArguments().iterator(); iterator.hasNext() && !withResourceTypeVariable;) {
		TypeTreeVisitor treeVisitor = new TypeTreeVisitor();
		iterator.next().accept(treeVisitor);
		withResourceTypeVariable = treeVisitor.isResourceTypeInstance();
	}
	super.visitParameterizedType(parameterizedTypeTree);
}
 

import org.sonar.plugins.java.api.tree.Tree; //导入依赖的package包/类
private void checkModelProviderCall(Tree tree, StatementTree statement) {
	MethodInvocationTreeVisitor methodInvocationTreeVisitor = new MethodInvocationTreeVisitor();
	statement.accept(methodInvocationTreeVisitor);
	if (methodInvocationTreeVisitor.isModelProviderGetCalled()) {
		context.reportIssue(this, tree, RULE_MESSAGE);
	}
}