Java Code Examples for com.sun.tools.javac.tree.JCTree#toString()

private static void analyzeAnnotationTree(
    final Source src, final EndPosTable endPosTable, final AnnotationTree at) {
  if (at instanceof JCTree.JCAnnotation) {
    JCTree.JCAnnotation anno = (JCTree.JCAnnotation) at;
    int startPos = anno.getPreferredPosition();
    int endPos = anno.getEndPosition(endPosTable);
    JCTree annotationType = anno.getAnnotationType();
    int annotationTypeEndPosition = annotationType.getEndPosition(endPosTable);
    Range range;
    if (endPos != annotationTypeEndPosition) {
      startPos = annotationTypeEndPosition;
    }
    range = Range.create(src, startPos + 1, endPos);
    Type type = anno.type;
    Annotation annotation;
    if (nonNull(type)) {
      annotation = new Annotation(type.toString(), startPos, range);
    } else {
      annotation = new Annotation(annotationType.toString(), startPos, range);
    }
    src.annotationMap.put(range.begin.line, annotation);
  }
}
 

void checkMatch(String code, JCTree tree) {
    String expect = code.replace("\n", NL);
    String found = tree.toString();
    if (!expect.equals(found)) {
        mismatches.add("Expected: " + expect + NL +
                "Obtained: " + found);
    } else {
        matches.add("Passed: " + expect);
    }
}
 

void checkMatch(String code, JCTree tree) {
    String expect = code.replace("\n", NL);
    String found = tree.toString();
    if (!expect.equals(found)) {
        mismatches.add("Expected: " + expect + NL +
                "Obtained: " + found);
    } else {
        matches.add("Passed: " + expect);
    }
}
 

void checkMatch(String code, JCTree tree) {
    String expect = code.replace("\n", NL);
    String found = tree.toString();
    if (!expect.equals(found)) {
        mismatches.add("Expected: " + expect + NL +
                "Obtained: " + found);
    } else {
        matches.add("Passed: " + expect);
    }
}
 

void checkMatch(String code, JCTree tree) {
    String expect = code.replace("\n", NL);
    String found = tree.toString();
    if (!expect.equals(found)) {
        mismatches.add("Expected: " + expect + NL +
                "Obtained: " + found);
    } else {
        matches.add("Passed: " + expect);
    }
}
 

@Nullable
public static IClass jcTypeToClass(JCTree.JCCompilationUnit unit, JCTree type) {
    if (type == null) {
        return null;
    }
    String className;
    if (type instanceof JCTree.JCTypeApply) {   //generic
        return jcTypeToClass(unit, ((JCTree.JCTypeApply) type).getType());
    } else {
        className = type.toString();
    }
    //try to find full class name
    className = findImportedClassName(unit, className);
    return JavaClassManager.getInstance().getParsedClass(className);
}
 

void checkMatch(String code, JCTree tree) {
    String expect = code.replace("\n", NL);
    String found = tree.toString();
    if (!expect.equals(found)) {
        mismatches.add("Expected: " + expect + NL +
                "Obtained: " + found);
    } else {
        matches.add("Passed: " + expect);
    }
}
 

void checkMatch(String code, JCTree tree) {
    String expect = code.replace("\n", NL);
    String found = tree.toString();
    if (!expect.equals(found)) {
        mismatches.add("Expected: " + expect + NL +
                "Obtained: " + found);
    } else {
        matches.add("Passed: " + expect);
    }
}
 

void checkMatch(String code, JCTree tree) {
    String expect = code.replace("\n", NL);
    String found = tree.toString();
    if (!expect.equals(found)) {
        mismatches.add("Expected: " + expect + NL +
                "Obtained: " + found);
    } else {
        matches.add("Passed: " + expect);
    }
}
 

private static void parseUnionVariable(
    JCTree.JCVariableDecl vd,
    int preferredPos,
    Source src,
    JCTree typeTree,
    String vName,
    Range nameRange,
    JCTree.JCTypeUnion union) {

  for (JCTree.JCExpression expression : union.getTypeAlternatives()) {

    String type = expression.toString();
    Variable variable = new Variable(vName, preferredPos, nameRange);
    type = src.getImportedClassFQCN(type, type);

    if (vd.getTag().equals(JCTree.Tag.VARDEF)) {
      variable.isDef = true;
    }

    String typeSym = typeTree.toString();
    boolean markUnUse = requireImport(src, typeSym, type);
    log.trace("typeSym:{} type:{} markUnuse:{}", typeSym, type, markUnUse);

    if (nonNull(type)) {
      variable.fqcn = TreeAnalyzer.markFQCN(src, type, markUnUse);
      src.getCurrentScope()
          .ifPresent(
              scope -> {
                scope.addVariable(variable);
                addSymbolIndex(src, scope, variable);
              });
    }
  }
}
 

void checkMatch(String code, JCTree tree) {
    String expect = code.replace("\n", NL);
    String found = tree.toString();
    if (!expect.equals(found)) {
        mismatches.add("Expected: " + expect + NL +
                "Obtained: " + found);
    } else {
        matches.add("Passed: " + expect);
    }
}
 

private String topLevelName(JCTree tree) {
	while (tree instanceof JCFieldAccess) tree = ((JCFieldAccess) tree).selected;
	return tree.toString();
}
 

/**
 * Checks if the given TypeReference node is likely to be a reference to the provided class.
 * 
 * @param type An actual type. This method checks if {@code typeNode} is likely to be a reference to this type.
 * @param node A Lombok AST node. Any node in the appropriate compilation unit will do (used to get access to import statements).
 * @param typeNode A type reference to check.
 */
public static boolean typeMatches(Class<?> type, JavacNode node, JCTree typeNode) {
	String typeName = typeNode.toString();
	
	TypeResolver resolver = new TypeResolver(node.getImportList());
	return resolver.typeMatches(node, type.getName(), typeName);
}