Now what is this all about? As in the AST article<\/a> our code is in the form of a plugin. But this is not the main point though we make the plugin a „Hello-World“-Plugin that contributes a button to the toolbar. On clicking this button a Java source file is generated with the main helloWorld method. This is done with specifying the necessary code in a string and generate a CompilationUnit from it. So let’s plunge in. This first listing shows how the compilation unit is produced. Now that we have an Abstract Syntax Tree representation of the HelloWorld class we can start manipulate it. Therefore we add a method to set name. To do that we have to generate new node for the MethodDeclaration. To this node we add all the needed bits. How to get at a source file existing in a project? Well first you have to retrieve the Java projects from the workspace, then select a project, go to the source folder and pass it down until you find your class:
\n(The compilation unit can also be gained by parsing an existing class, e.g. some class rump generated with JET, but that is not the focus of this article)
\nHaving generated the AST of a simple class we want add further methods to this class. There are two interessting ways to do that:<\/p>\n\n
\n
\n
\n\t\tString helloWorld =\"\\n\"+
\n\t\t\t\"public class HelloWorld {\\n\"+
\n\t\t\t\"\\n\"+
\n\t\t\t\"\tprivate String name=\\\"\\\"\\n\\n\"+
\n\t\t\t\"\t\/**\\n\"+
\n\t\t\t\"\t * \\n\"+
\n\t\t\t\"\t *\/\\n\"+
\n\t\t\t\"\t public void sayHello() {\\n\"+
\n\t\t\t\"\t\tSystem.out.println(\\\"Hello \\\"+name+\\\"!\\\");\\n\"+
\n\t\t\t\"\t }\\n\"+
\n\t\t\t\"\\n\"+
\n\t\t\t\"}\";
\n\t\tASTParser parser = ASTParser.newParser(AST.JLS3); \/\/ Java 5.0 and up
\n\t\tparser.setKind(ASTParser.K_COMPILATION_UNIT);
\n\t\tparser.setSource(helloWorld.toCharArray());
\n\t\tparser.setResolveBindings(true);
\n\t\tparser.setBindingsRecovery(true);
\n\t\tunit = (CompilationUnit) parser.createAST(null \/* IProgrssMonitor*\/);
\n\t\tdocument=new Document(helloWorld);
\n<\/code>
\nListing 1: from class ch.sahits.tut.ast.ClassGenerator<\/p>\n
\nAs the name suggests this is quite abstract and my produce considerable brain pain. In such a case I find it extremly helpful to visualise the DOM tree I want to create. Here is the API documentation<\/a>(look in the package org.eclipse.jdt.core.dom) a great help since if you know with which element to start you can find your way through the needed nodes which have all meaningful names.
\n![\"AST](\"http:\/\/www.sahits.ch\/blog\/wp-content\/uploads\/2008\/05\/ast_setname.gif\")
\nThe next step is to add a method by coping an AST subtree. Normally you will be working on some project where you can access some class to get the Abstract Syntax subtree you want to copy. Since this article is somewhat simplified we will generate our AST we copy from like the AST in Listing 1. At the end of the article I will show how a class in a project can be accessed.
\nSo far this article tells you nothing new since the code is basically identical with the second Link<\/a>. Let us now take a look at coping a subtree. AST nodes cannot be re-parented, once connected to an AST, they cannot be attached to a different place of the tree. Though it is easy to create a copy from a subtree: ASTNode ASTNode.copySubtree(AST target, ASTNode nodeToCopy)<\/code>. So the tricky part is to find the nodeToCopy in the source:
\n
\n\t\tCompilationUnit unit2 = (CompilationUnit) parser2.createAST(null \/* IProgrssMonitor*\/);
\n\t\tAST ast2=unit2.getAST();
\n\t\tASTRewrite astRewrite= ASTRewrite.create(ast);
\n\t\t\/\/ find the node to be copied
\n\t\tList
\n\t\t\/\/ Add the node
\n\t\tMethodDeclaration method = null;
\n\t\tfor (Iterator iterator = delcs.iterator(); iterator.hasNext();) {
\n\t\t\tBodyDeclaration decl = (BodyDeclaration) iterator.next();
\n\t\t\tif (decl instanceof MethodDeclaration){
\n\t\t\t\tif (((MethodDeclaration)decl).getName().getIdentifier().equals(\"getName\")){
\n\t\t\t\t\tmethod = (MethodDeclaration) decl;
\n\t\t\t\t\tbreak;
\n\t\t\t\t}
\n\t\t\t}
\n\t\t}
\n<\/bodydeclaration><\/code>
\nListing 2: from class ch.sahits.tut.ast.ClassGenerator
\nAnd now the saving back:
\n
\n\t\tMethodDeclaration copy = (MethodDeclaration) ASTNode.copySubtree(ast, method);
\n\t\tList
\n\t\tbodyDecls.add(copy);
\n\t\tListRewrite lrw = astRewrite.getListRewrite(((TypeDeclaration)unit.types().get(0)), TypeDeclaration.BODY_DECLARATIONS_PROPERTY);
\n\t\tlrw.insertLast(copy, null);
\n
\nListing 3: from class ch.sahits.tut.ast.ClassGenerator
\nIn our second case (the node created from scratch) the saving is identical from the second line. You substitute the <\/code>copy<\/code> with method<\/code> since method was created on the same AST.
\nCreating a file from a compilation unit generated in such a way (not parsed from an existing source file) is easy:
\n
\n\t\tString newSource = document.get(); \/\/ created in the last line of Listing 1
\n\t\ttempFile=File.createTempFile(\"HelloWorld\", \"java\");
\n\t\tFileOutputStream fos = new FileOutputStream(tempFile);
\n\t\tfos.write(newSource.getBytes());
\n\t\tfos.flush();
\n<\/code>
\nIf we had parsed from a class we would have had to undertake the following steps:<\/p>\n\n
ASTRewrite astRewrite= ASTRewrite.create(ast);<\/code><\/li>\nunit.recordModifications();<\/code><\/li>\n
\n\/\/ computation of the text edits
\n TextEdit edits = astRewrite.rewriteAST(document,null \/* default Options *\/);
\n \/\/ computation of the new source code
\n edits.apply(document);
\n String newSource = document.get();
\n \/\/ update of the compilation unit
\n ICompilationUnit cu = (ICompilationUnit)unit.getJavaElement();
\n cu.getBuffer().setContents(newSource);<\/code>\n<\/li>\n<\/ol>\n
\n
\n\tpublic File findSourceFile(Class className) throws JavaModelException{
\n\t\tIJavaProject[] projects= JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()).getJavaProjects();
\n\t\tIPackageFragmentRoot[] srcs =projects[0].getAllPackageFragmentRoots();
\n\t\tString path = className.getName();
\n\t\tfor (int i = 0; i < srcs.length; i++) {\n\t\t\tif (srcs[i].getPackageFragment(path).exists()){\n\t\t\t\t\/\/ found\n\t\t\t\tIResource res= srcs[i].getPackageFragment(path).getResource();\n\t\t\t\treturn new File(res.getLocationURI());\n\t\t\t}\n\t\t}\n\t\treturn null;\n\t}\n<\/code>
\nListing 4: from class ch.sahits.tut.ast.FindSource
\nYou can just as easy retrieve an instance of an ICompilationUnit that is needed to parse the AST. Just replace the return statement with the following expression:<\/code>srcs[i].getPackageFragment(path).getCompilationUnit(path.substring(path.lastIndexOf(\".\")+1)+\".java\");<\/code><\/p>\n