下面列出了怎么用org.eclipse.jdt.core.dom.ASTParser的API类实例代码及写法，或者点击链接到github查看源代码。
public static ASTParser createParser(String sourceVersion) {
ASTParser parser = ASTParser.newParser(AST.JLS10);
parser.setKind(ASTParser.K_COMPILATION_UNIT);
parser.setResolveBindings(true);
//TODO
// parser.setUnitName(unitName);
parser.setBindingsRecovery(true);
parser.setStatementsRecovery(true);
Map options = JavaCore.getOptions();
options.put(JavaCore.COMPILER_COMPLIANCE, sourceVersion);
options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, sourceVersion);
options.put(JavaCore.COMPILER_SOURCE, sourceVersion);
parser.setCompilerOptions(options);
return parser;
}
private static void parseAST(String[] srcFiles, Charset srcCharset,
String[] classPathEntries, FileASTRequestor requestor) {
ASTParser parser = ASTParser.newParser(AST.JLS8);
Map<String, String> options = JavaCore.getOptions();
JavaCore.setComplianceOptions(JavaCore.VERSION_1_8, options);
parser.setCompilerOptions(options);
parser.setKind(ASTParser.K_COMPILATION_UNIT);
parser.setResolveBindings(true);
parser.setBindingsRecovery(true);
parser.setEnvironment(classPathEntries, null, null, true);
String[] srcEncodings = new String[srcFiles.length];
for (int i = 0; i < srcEncodings.length; i++) {
srcEncodings[i] = srcCharset.name();
}
parser.createASTs(
srcFiles, srcEncodings, new String[]{}, requestor, null);
}
/** Visit the given Java compilation unit.
*
* @param jfile the compilation unit.
*/
protected void visitJavaCompilationUnit(IFile jfile) {
final ICompilationUnit cu = JavaCore.createCompilationUnitFrom(jfile);
if (cu != null) {
final ASTParser parser = ASTParser.newParser(IASTSharedValues.SHARED_AST_LEVEL);
parser.setSource(cu);
parser.setFocalPosition(0);
final CompilationUnit root = (CompilationUnit) parser.createAST(null);
final PackageDeclaration packDecl = root.getPackage();
final IPath packPath = jfile.getParent().getFullPath();
final String cuName = jfile.getName();
if (packDecl == null) {
addToMap(this.sourceFolders, packPath, new Path(cuName));
} else {
final IPath relPath = new Path(packDecl.getName().getFullyQualifiedName().replace('.', '/'));
final IPath folderPath = getFolderPath(packPath, relPath);
if (folderPath != null) {
addToMap(this.sourceFolders, folderPath, relPath.append(cuName));
}
}
}
}
private HashMap<String, HashSet<String>> parseKCUnit(String snippet) throws IOException {
HashMap<String, HashSet<String>> tokens = new HashMap<String, HashSet<String>>();
ASTParser parser = ASTParser.newParser(AST.JLS9);
parser.setResolveBindings(true);
parser.setKind(ASTParser.K_COMPILATION_UNIT);
parser.setSource(snippet.toCharArray());
parser.setResolveBindings(true);
Hashtable<String, String> options = JavaCore.getOptions();
options.put(JavaCore.COMPILER_DOC_COMMENT_SUPPORT, JavaCore.ENABLED);
parser.setCompilerOptions(options);
try {
CompilationUnit cu = (CompilationUnit) parser.createAST(null);
MyASTVisitor myVisitor = new MyASTVisitor();
cu.accept(myVisitor);
tokens = myVisitor.getTokens();
} catch (Exception exc) {
logger.error("JDT parsing error");
}
return tokens;
}
private UMLModelASTReader(File rootFolder, ASTParser parser, List<String> javaFiles, Set<String> repositoryDirectories) {
this.umlModel = new UMLModel(repositoryDirectories);
this.projectRoot = rootFolder.getPath();
this.parser = parser;
final String[] emptyArray = new String[0];
String[] filesArray = new String[javaFiles.size()];
for (int i = 0; i < filesArray.length; i++) {
filesArray[i] = rootFolder + File.separator + javaFiles.get(i).replaceAll("/", systemFileSeparator);
}
FileASTRequestor fileASTRequestor = new FileASTRequestor() {
@Override
public void acceptAST(String sourceFilePath, CompilationUnit ast) {
String relativePath = sourceFilePath.substring(projectRoot.length() + 1).replaceAll(systemFileSeparator, "/");
processCompilationUnit(relativePath, ast);
}
};
this.parser.createASTs((String[]) filesArray, null, emptyArray, fileASTRequestor, null);
}
private void initDomAST() {
if (isReadOnly())
return;
ASTParser parser= ASTParser.newParser(AST.JLS8);
parser.setSource(getCompilationUnit());
parser.setResolveBindings(true);
org.eclipse.jdt.core.dom.ASTNode domAst = parser.createAST(new NullProgressMonitor());
// org.eclipse.jdt.core.dom.AST ast = domAst.getAST();
NodeFinder nf = new NodeFinder(domAst, getCompletionOffset(), 1);
org.eclipse.jdt.core.dom.ASTNode cv = nf.getCoveringNode();
bodyDeclaration = ASTResolving.findParentBodyDeclaration(cv);
parentDeclaration = ASTResolving.findParentType(cv);
domInitialized = true;
}
private void visitCompilationUnit(IFile file) {
ICompilationUnit cu= JavaCore.createCompilationUnitFrom(file);
if (cu != null) {
ASTParser parser= ASTParser.newParser(ASTProvider.SHARED_AST_LEVEL);
parser.setSource(cu);
parser.setFocalPosition(0);
CompilationUnit root= (CompilationUnit)parser.createAST(null);
PackageDeclaration packDecl= root.getPackage();
IPath packPath= file.getParent().getFullPath();
String cuName= file.getName();
if (packDecl == null) {
addToMap(fSourceFolders, packPath, new Path(cuName));
} else {
IPath relPath= new Path(packDecl.getName().getFullyQualifiedName().replace('.', '/'));
IPath folderPath= getFolderPath(packPath, relPath);
if (folderPath != null) {
addToMap(fSourceFolders, folderPath, relPath.append(cuName));
}
}
}
}
private CompilationUnit getRecoveredAST(IDocument document, int offset, Document recoveredDocument) {
CompilationUnit ast = CoreASTProvider.getInstance().getAST(fCompilationUnit, CoreASTProvider.WAIT_YES, null);
if (ast != null) {
recoveredDocument.set(document.get());
return ast;
}
char[] content= document.get().toCharArray();
// clear prefix to avoid compile errors
int index= offset - 1;
while (index >= 0 && Character.isJavaIdentifierPart(content[index])) {
content[index]= ' ';
index--;
}
recoveredDocument.set(new String(content));
final ASTParser parser= ASTParser.newParser(IASTSharedValues.SHARED_AST_LEVEL);
parser.setResolveBindings(true);
parser.setStatementsRecovery(true);
parser.setSource(content);
parser.setUnitName(fCompilationUnit.getElementName());
parser.setProject(fCompilationUnit.getJavaProject());
return (CompilationUnit) parser.createAST(new NullProgressMonitor());
}
private static IBinding getHoveredNodeBinding(IJavaElement element, ITypeRoot typeRoot, IRegion region) {
if (typeRoot == null || region == null) {
return null;
}
IBinding binding;
ASTNode node = getHoveredASTNode(typeRoot, region);
if (node == null) {
ASTParser p = ASTParser.newParser(IASTSharedValues.SHARED_AST_LEVEL);
p.setProject(element.getJavaProject());
p.setBindingsRecovery(true);
try {
binding = p.createBindings(new IJavaElement[] { element }, null)[0];
} catch (OperationCanceledException e) {
return null;
}
} else {
binding = resolveBinding(node);
}
return binding;
}
private CompilationUnit createAst(ICompilationUnit unit, Map<String, String> cleanUpOptions, IProgressMonitor monitor) {
IJavaProject project= unit.getJavaProject();
if (compatibleOptions(project, cleanUpOptions)) {
CompilationUnit ast= SharedASTProvider.getAST(unit, SharedASTProvider.WAIT_NO, monitor);
if (ast != null)
return ast;
}
ASTParser parser= CleanUpRefactoring.createCleanUpASTParser();
parser.setSource(unit);
Map<String, String> compilerOptions= RefactoringASTParser.getCompilerOptions(unit.getJavaProject());
compilerOptions.putAll(cleanUpOptions);
parser.setCompilerOptions(compilerOptions);
return (CompilationUnit)parser.createAST(monitor);
}
protected CompilationUnit prepareAST(String javaFile) throws IOException {
File projectRoot = new File(VALIDATION_EXAMPLES_ROOT).getAbsoluteFile();
File sourceFile = new File(projectRoot.getCanonicalPath() + getValidationExamplesPackage() + javaFile);
ASTParser parser = ASTParser.newParser(AST.JLS8);
char[] content = SharedUtils.getFileContents(sourceFile);
String[] classpath = {};
String[] sourcepath = { projectRoot.getCanonicalPath(), new File(API_SRC_LOC).getCanonicalPath() };
String[] encodings = { "UTF-8", "UTF-8" };
parser.setSource(content);
parser.setResolveBindings(true);
parser.setBindingsRecovery(true);
parser.setUnitName(sourceFile.getName());
parser.setKind(ASTParser.K_COMPILATION_UNIT);
parser.setEnvironment(classpath, sourcepath, encodings, true);
return (CompilationUnit) parser.createAST(null);
}
@Override
public ASTParserFactory.ASTParserWrapper createJavaParser(final Object context) {
if ((context instanceof IJavaElement)) {
final IJavaProject project = ((IJavaElement)context).getJavaProject();
final String projlevel = project.getOption(JavaCore.COMPILER_SOURCE, true);
final ASTParser parser = this.createDefaultJavaParser(projlevel);
if ((context instanceof IJavaProject)) {
parser.setProject(project);
this.tweakOptions(parser, project);
} else {
if ((context instanceof ICompilationUnit)) {
parser.setSource(((ICompilationUnit)context));
this.tweakOptions(parser, ((ICompilationUnit)context).getJavaProject());
}
}
return new ASTParserFactory.ASTParserWrapper(projlevel, parser);
}
return super.createJavaParser(context);
}
protected static void dumpJava(final String content) {
final ASTParser parser = ASTParser.newParser(astLevel);
parser.setKind(ASTParser.K_COMPILATION_UNIT);
parser.setSource(content.toCharArray());
final Map<?, ?> options = JavaCore.getOptions();
JavaCore.setComplianceOptions(javaVersion, options);
parser.setCompilerOptions(options);
final CompilationUnit cu = (CompilationUnit) parser.createAST(null);
try {
final UglyMathCommentsExtractor cex = new UglyMathCommentsExtractor(cu, content);
final ASTDumper dumper = new ASTDumper(cex);
dumper.dump(cu);
cex.close();
} catch (final Exception e) {}
}
protected final ASTParser createDefaultJavaParser(final String javaVersion) {
ASTParser parser = null;
final Hashtable<String, String> options = JavaCore.getOptions();
try {
parser = ASTParser.newParser(ASTParserFactory.asJLS(javaVersion));
JavaCore.setComplianceOptions(javaVersion, options);
} catch (final Throwable _t) {
if (_t instanceof IllegalArgumentException) {
parser = ASTParser.newParser(ASTParserFactory.asJLS(this.minParserApiLevel));
JavaCore.setComplianceOptions(this.minParserApiLevel, options);
} else {
throw Exceptions.sneakyThrow(_t);
}
}
options.put(JavaCore.COMPILER_DOC_COMMENT_SUPPORT, JavaCore.ENABLED);
parser.setCompilerOptions(options);
parser.setStatementsRecovery(true);
parser.setResolveBindings(true);
parser.setBindingsRecovery(true);
return parser;
}
private List<TypeCheckElimination> generateTypeCheckEliminationsWithinJavaProject(IJavaProject javaProject, TypeCheckElimination elimination) {
List<TypeCheckElimination> typeCheckEliminations = new ArrayList<TypeCheckElimination>();
try {
IPackageFragmentRoot[] iPackageFragmentRoots = javaProject.getPackageFragmentRoots();
for(IPackageFragmentRoot iPackageFragmentRoot : iPackageFragmentRoots) {
IJavaElement[] children = iPackageFragmentRoot.getChildren();
for(IJavaElement child : children) {
if(child.getElementType() == IJavaElement.PACKAGE_FRAGMENT) {
IPackageFragment iPackageFragment = (IPackageFragment)child;
ICompilationUnit[] iCompilationUnits = iPackageFragment.getCompilationUnits();
for(ICompilationUnit iCompilationUnit : iCompilationUnits) {
ASTParser parser = ASTParser.newParser(ASTReader.JLS);
parser.setKind(ASTParser.K_COMPILATION_UNIT);
parser.setSource(iCompilationUnit);
parser.setResolveBindings(true); // we need bindings later on
CompilationUnit compilationUnit = (CompilationUnit)parser.createAST(null);
typeCheckEliminations.addAll(generateTypeCheckEliminationsWithinCompilationUnit(compilationUnit, elimination));
}
}
}
}
} catch (JavaModelException e) {
e.printStackTrace();
}
return typeCheckEliminations;
}
/**
* @param unitName some CU name e.g. Clazz. If unitName is null, a body declaration content is considered.<br>
* See org.eclipse.jdt.core.dom.ASTParser.setUnitName(String)
* @param javaSrc Java source code as String
* @param imports Additional imports to add
* @param parser ASTParser to use
* @param conditionalExpressionsAllowed informs, if conditional aka ternary expressions like "cond? a : b" are allowed (by preference setting)
*/
private JavaConverter.ConversionResult internalToXtend(final String unitName, final String javaSrc, final String[] imports, final ASTParserFactory.ASTParserWrapper parser, final boolean conditionalExpressionsAllowed) {
final StringBuilder javaSrcBuilder = new StringBuilder();
if ((imports != null)) {
final Consumer<String> _function = (String it) -> {
javaSrcBuilder.append((("import " + it) + ";"));
};
((List<String>)Conversions.doWrapArray(imports)).forEach(_function);
}
if ((unitName == null)) {
parser.setUnitName("MISSING");
StringConcatenation _builder = new StringConcatenation();
_builder.append("class MISSING { ");
_builder.append(javaSrc);
_builder.append(" }");
javaSrcBuilder.append(_builder);
} else {
parser.setUnitName(unitName);
javaSrcBuilder.append(javaSrc);
}
parser.setKind(ASTParser.K_COMPILATION_UNIT);
final String preparedJavaSrc = javaSrcBuilder.toString();
parser.setSource(preparedJavaSrc.toCharArray());
final ASTNode result = parser.createAST();
return this.executeAstFlattener(preparedJavaSrc, result, parser.getTargetLevel(), false, conditionalExpressionsAllowed);
}
private CompilationUnit getRecoveredAST(IDocument document, int offset, Document recoveredDocument) {
CompilationUnit ast= SharedASTProvider.getAST(fCompilationUnit, SharedASTProvider.WAIT_ACTIVE_ONLY, null);
if (ast != null) {
recoveredDocument.set(document.get());
return ast;
}
char[] content= document.get().toCharArray();
// clear prefix to avoid compile errors
int index= offset - 1;
while (index >= 0 && Character.isJavaIdentifierPart(content[index])) {
content[index]= ' ';
index--;
}
recoveredDocument.set(new String(content));
final ASTParser parser= ASTParser.newParser(ASTProvider.SHARED_AST_LEVEL);
parser.setResolveBindings(true);
parser.setStatementsRecovery(true);
parser.setSource(content);
parser.setUnitName(fCompilationUnit.getElementName());
parser.setProject(fCompilationUnit.getJavaProject());
return (CompilationUnit) parser.createAST(new NullProgressMonitor());
}
public static boolean isValidVarargsExpression(String string) {
String trimmed= string.trim();
if ("".equals(trimmed)) //speed up for a common case //$NON-NLS-1$
return true;
StringBuffer cuBuff= new StringBuffer();
cuBuff.append("class A{ {m("); //$NON-NLS-1$
int offset= cuBuff.length();
cuBuff.append(trimmed)
.append(");}}"); //$NON-NLS-1$
ASTParser p= ASTParser.newParser(ASTProvider.SHARED_AST_LEVEL);
p.setSource(cuBuff.toString().toCharArray());
CompilationUnit cu= (CompilationUnit) p.createAST(null);
Selection selection= Selection.createFromStartLength(offset, trimmed.length());
SelectionAnalyzer analyzer= new SelectionAnalyzer(selection, false);
cu.accept(analyzer);
ASTNode[] selectedNodes= analyzer.getSelectedNodes();
if (selectedNodes.length == 0)
return false;
for (int i= 0; i < selectedNodes.length; i++) {
if (! (selectedNodes[i] instanceof Expression))
return false;
}
return true;
}
protected void testQuickfix(InputStream testdataStream, AbstractASTResolution quickfix)
throws Exception {
QuickfixTestData[] testdata = getTestData(testdataStream);
for (int i = 0; i < testdata.length; i++) {
org.eclipse.jface.text.Document doc = new org.eclipse.jface.text.Document(testdata[i].input);
ASTParser parser = ASTParser.newParser(AST.JLS3);
parser.setSource(doc.get().toCharArray());
CompilationUnit compUnit = (CompilationUnit) parser.createAST(new NullProgressMonitor());
compUnit.recordModifications();
IRegion region = doc.getLineInformation(testdata[i].line);
int markerStartOffset = region.getOffset() + testdata[i].position;
System.out.println("Invoke quickfix " + quickfix.getClass() + " with markerStartOffset="
+ markerStartOffset);
compUnit.accept(quickfix.handleGetCorrectingASTVisitor(region, markerStartOffset));
Map<String, String> options = new HashMap<>();
options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, JavaCore.SPACE);
options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, "4");
options.put(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES,
"true");
options.put(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH,
"true");
TextEdit edit = compUnit.rewrite(doc, options);
edit.apply(doc);
assertEquals(testdata[i].result, doc.get());
}
}
/**
* Parse a source file, attempting to resolve references in the AST. Valid Java files will usually
* have errors in the CompilationUnit returned by this method, because classes, imports and
* methods will be undefined (because we're only looking at a single file from a whole project).
* Consequently, do not assume the returned object's getProblems() is an empty list. On the other
* hand, {@link @parseSource} returns a CompilationUnit fit for syntax checking purposes.
*/
private static CompilationUnit parseAndResolveSource(String source) {
ASTParser parser = createCompilationUnitParser();
parser.setSource(source.toCharArray());
parser.setResolveBindings(true);
parser.setBindingsRecovery(true);
parser.setEnvironment(
EMPTY_STRING_ARRAY,
EMPTY_STRING_ARRAY,
EMPTY_STRING_ARRAY,
true /* includeRunningVMBootclasspath */);
parser.setUnitName("dontCare");
return (CompilationUnit) parser.createAST(null);
}
private List<ClassObject> parseAST(ICompilationUnit iCompilationUnit) {
ASTInformationGenerator.setCurrentITypeRoot(iCompilationUnit);
IFile iFile = (IFile)iCompilationUnit.getResource();
ASTParser parser = ASTParser.newParser(JLS);
parser.setKind(ASTParser.K_COMPILATION_UNIT);
parser.setSource(iCompilationUnit);
parser.setResolveBindings(true); // we need bindings later on
CompilationUnit compilationUnit = (CompilationUnit)parser.createAST(null);
return parseAST(compilationUnit, iFile);
}
/**
* setupParser Method that sets up the Parser and creates a visitor for a specific unit
*
* @param unit Unit from getUnitForParser
*/
private void setupParser(final ICompilationUnit unit) {
final ASTParser parser = ASTParser.newParser(AST.JLS10);
parser.setKind(ASTParser.K_COMPILATION_UNIT);
parser.setSource(unit);
parser.setResolveBindings(true);
final CompilationUnit cu = (CompilationUnit) parser.createAST(null);
cu.accept(createMarkerVisitor(unit, cu));
}
/**
* build The standard method that gets called by eclipse when initiating a build for its specified Nature
*/
@Override
protected IProject[] build(final int kind, final Map args, final IProgressMonitor monitor) throws CoreException {
clean(null);
this.parser = ASTParser.newParser(AST.JLS10);
this.parser.setKind(ASTParser.K_COMPILATION_UNIT);
final IProject project = getProject();
try {
startMarking(project);
}
catch (final CoreException e) {
Activator.getDefault().logError(e);
}
return null;
}
private ASTParser newASTParser(boolean resolveBinding) {
ASTParser parser = ASTParser.newParser(AST_JLS_VERSION);
parser.setCompilerOptions(compilerOptions);
parser.setResolveBindings(resolveBinding);
parser.setEnvironment(
Iterables.toArray(classpathEntries, String.class), new String[0], new String[0], false);
return parser;
}
public static ASTNode newStatement(AST ast, String content) {
StringBuffer buffer= new StringBuffer(STATEMENT_HEADER);
buffer.append(content);
buffer.append(STATEMENT_FOOTER);
ASTParser p= ASTParser.newParser(ast.apiLevel());
p.setSource(buffer.toString().toCharArray());
CompilationUnit root= (CompilationUnit) p.createAST(null);
ASTNode result= ASTNode.copySubtree(ast, NodeFinder.perform(root, STATEMENT_HEADER.length(), content.length()));
result.accept(new PositionClearer());
return result;
}
/**
* Parses the provided file, using the given libraryPaths and sourcePaths as context. The libraries may be either
* jar files or references to directories containing class files.
*
* The sourcePaths must be a reference to the top level directory for sources (eg, for a file
* src/main/java/org/example/Foo.java, the source path would be src/main/java).
*
* The wildcard resolver provides a fallback for processing wildcard imports that the underlying parser was unable
* to resolve.
*/
public static List<ClassReference> analyze(WildcardImportResolver importResolver, Set<String> libraryPaths, Set<String> sourcePaths,
Path sourceFile)
{
ASTParser parser = ASTParser.newParser(AST.JLS11);
parser.setEnvironment(libraryPaths.toArray(new String[libraryPaths.size()]), sourcePaths.toArray(new String[sourcePaths.size()]), null, true);
parser.setBindingsRecovery(false);
parser.setResolveBindings(true);
Map options = JavaCore.getOptions();
JavaCore.setComplianceOptions(JavaCore.VERSION_1_8, options);
parser.setCompilerOptions(options);
String fileName = sourceFile.getFileName().toString();
parser.setUnitName(fileName);
try
{
parser.setSource(FileUtils.readFileToString(sourceFile.toFile()).toCharArray());
}
catch (IOException e)
{
throw new ASTException("Failed to get source for file: " + sourceFile.toString() + " due to: " + e.getMessage(), e);
}
parser.setKind(ASTParser.K_COMPILATION_UNIT);
CompilationUnit cu = (CompilationUnit) parser.createAST(null);
ReferenceResolvingVisitor visitor = new ReferenceResolvingVisitor(importResolver, cu, sourceFile.toString());
cu.accept(visitor);
return visitor.getJavaClassReferences();
}
private List<Set<Integer>> consistentModification(List<Modification> modifications){
List<Set<Integer>> result = new LinkedList<>();
String regex = "[A-Za-z_][0-9A-Za-z_.]*";
Pattern pattern = Pattern.compile(regex);
for(int i = 0; i < modifications.size(); i++){
Modification modification = modifications.get(i);
if(modification instanceof Revision){
Set<Integer> consistant = new HashSet<>();
consistant.add(i);
for(int j = i + 1; j < modifications.size(); j++){
Modification other = modifications.get(j);
if(other instanceof Revision){
if(modification.compatible(other) && modification.getTargetString().equals(other.getTargetString())){
ASTNode node = JavaFile.genASTFromSource(modification.getTargetString(), ASTParser.K_EXPRESSION);
if(node instanceof Name || node instanceof FieldAccess || pattern.matcher(modification.getTargetString()).matches()){
consistant.add(j);
}
}
}
}
if(consistant.size() > 1){
result.add(consistant);
}
}
}
return result;
}
private static CompilationUnit createAST(IJavaElement element, String cuSource) {
Assert.isNotNull(element);
ASTParser parser= ASTParser.newParser(ASTProvider.SHARED_AST_LEVEL);
IJavaProject javaProject= element.getJavaProject();
parser.setProject(javaProject);
Map<String, String> options= javaProject.getOptions(true);
options.put(JavaCore.COMPILER_DOC_COMMENT_SUPPORT, JavaCore.ENABLED); // workaround for https://bugs.eclipse.org/bugs/show_bug.cgi?id=212207
parser.setCompilerOptions(options);
parser.setSource(cuSource.toCharArray());
return (CompilationUnit) parser.createAST(null);
}
/**
* generate {@code CompilationUnit} from source code based on the specific
* type (e.g., {@code ASTParser.K_COMPILATION_UNIT})
*
* @param icu
* @param type
* @return
*/
public static ASTNode genASTFromSource(String icu, int type) {
ASTParser astParser = ASTParser.newParser(AST.JLS8);
Map<?, ?> options = JavaCore.getOptions();
JavaCore.setComplianceOptions(JavaCore.VERSION_1_7, options);
astParser.setCompilerOptions(options);
astParser.setSource(icu.toCharArray());
astParser.setKind(type);
astParser.setResolveBindings(true);
astParser.setBindingsRecovery(true);
return astParser.createAST(null);
}
protected static String parseJava(final String content) {
final StringBuilder sb = new StringBuilder();
final FileASTRequestor r = new FileASTRequestor() {
@Override
public void acceptAST(String sourceFilePath, CompilationUnit cu) {
final ASTRoot.Builder ast = ASTRoot.newBuilder();
try {
ast.addNamespaces(visitor.getNamespaces(cu));
} catch (final Exception e) {
System.err.println(e);
e.printStackTrace();
}
sb.append(JsonFormat.printToString(ast.build()));
}
};
Map<String, String> fileContents = new HashMap<String, String>();
fileContents.put("", content);
@SuppressWarnings("rawtypes")
Map options = JavaCore.getOptions();
options.put(JavaCore.COMPILER_COMPLIANCE, javaVersion);
options.put(JavaCore.COMPILER_SOURCE, javaVersion);
ASTParser parser = ASTParser.newParser(astLevel);
parser.setCompilerOptions(options);
parser.setEnvironment(new String[0], new String[]{}, new String[]{}, true);
parser.setResolveBindings(true);
parser.createASTs(fileContents, new String[]{""}, null, new String[0], r, null);
return FileIO.normalizeEOL(sb.toString());
}