org.eclipse.jdt.ui.tests/examples/org/eclipse/jdt/ui/examples/ASTChildConstantsGenerator.java - jdt/eclipse.jdt.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2003 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Common Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/cpl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.ui.examples;

 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.text.Collator;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Hashtable;
 import java.util.List;

 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;

 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.Signature;
 import org.eclipse.jdt.core.ToolFactory;
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.ASTVisitor;

 /**
  *
  */
 public class ASTChildConstantsGenerator extends TestCase {

 	private static final String LIST= "java.util.List";

 	public static TypeFilter fgListFilter= new NodeTypeFilter(List.class);
 	public static TypeFilter fgASTFilter= new NodeTypeFilter(ASTNode.class);
 	public static TypeFilter fgListAndASTFilter=  new PrimitiveTypeFilter(true);
 	public static TypeFilter fgPrimitiveFilter= new PrimitiveTypeFilter(false);
 	public static TypeFilter fgNoFilter= new TypeFilter();

 	public static class TypeFilter {
 		public boolean accept(Class returnType) {
 			return true;
 		}
 	}

 	public static class NodeTypeFilter extends TypeFilter {
 		private Class fClass;

 		public NodeTypeFilter(Class cl) {
 			fClass= cl;
 		}

 		public boolean accept(Class returnType) {
 			return fClass.isAssignableFrom(returnType);
 		}
 	}

 	public static class PrimitiveTypeFilter extends TypeFilter {

 		private boolean fInvert;

 		public PrimitiveTypeFilter(boolean b) {
 			fInvert= b;
 		}

 		public boolean accept(Class returnType) {
 			return fInvert ^ (!LIST.equals(returnType.getName()) && !ASTNode.class.isAssignableFrom(returnType));
 		}
 	}


 	public class ClassNameComparer implements Comparator {

 		private Collator fCollator= Collator.getInstance();

 		public int compare(Object o1, Object o2) {
 			String name1= ((Class)o1).getName();
 			String name2= ((Class)o2).getName();
 			return fCollator.compare(name1, name2);
 		}

 	}

 	public class MethodNameComparer implements Comparator {

 		private Collator fCollator= Collator.getInstance();

 		public int compare(Object o1, Object o2) {
 			String name1= ((Method)o1).getName();
 			String name2= ((Method)o2).getName();
 			return fCollator.compare(name1, name2);
 		}

 	}

 	public class MethodTypeComparer implements Comparator {

 		private Collator fCollator= Collator.getInstance();

 		public int compare(Object o1, Object o2) {
 			Method m1= (Method)o1;
 			Method m2= (Method)o2;
 			boolean isList1= LIST.equals(m1.getReturnType().getName());
 			boolean isList2= LIST.equals(m2.getReturnType().getName());
 			if (isList1 && !isList2) {
 				return 1;
 			} else if (!isList1 && isList2) {
 				return -1;
 			}
 			String name1= m1.getName();
 			String name2= m2.getName();
 			return fCollator.compare(name1, name2);
 		}

 	}

 	private static final Class THIS= ASTChildConstantsGenerator.class;

 	private static HashSet fgPropertyIgnoreList;

 	static {
 		fgPropertyIgnoreList= new HashSet();
 		fgPropertyIgnoreList.add("setProperty");
 		fgPropertyIgnoreList.add("setParent");
 		fgPropertyIgnoreList.add("setFlags");
 		fgPropertyIgnoreList.add("setLeadingComment");
 	}


 	public ASTChildConstantsGenerator(String name) {
 		super(name);


 	}

 	public static Test allTests() {
 		return new TestSuite(THIS);
 	}

 	public static Test suite() {
 		if (false) {
 			return allTests();
 		} else {
 			TestSuite suite= new TestSuite();
 			suite.addTest(new ASTChildConstantsGenerator("createGeneratedCU"));
 			return suite;
 		}
 	}

 	protected void setUp() throws Exception {
 	}


 	protected void tearDown() throws Exception {
 	}


 	public void createGeneratedCU() throws Exception {

 		Class[] astClases= getASTClasses();
 		Arrays.sort(astClases, new ClassNameComparer());

 		StringBuffer buf= new StringBuffer();
 		buf.append("package org.eclipse.jdt.internal.corext.dom;\n\n");
 		buf.append("import java.util.List;");
 		buf.append("import org.eclipse.jdt.core.dom.*;\n\n");
 		buf.append("public class ASTNodeConstants {\n");

 		createPropertyList(astClases, buf);
 		createPropertyValidator(astClases, buf);
 		createIsListTest(astClases, buf);
 		createIsAttributeTest(astClases, buf);
 		createListAccessor(astClases, buf);
 		createGetNodeChild(astClases, buf);
 		createGetPropertyOfNode(astClases, buf);
 		createGetNodeChildProperties(astClases, buf);
 		createGetChildPropertyName(astClases, buf);

 		buf.append("}");

 		String code= buf.toString();

 		Hashtable options= JavaCore.getOptions();
 		options.put(JavaCore.FORMATTER_LINE_SPLIT, "999");

 		// new formatter
 		//TextEdit edit= ToolFactory.createCodeFormatter(options).format(CodeFormatter.K_COMPILATION_UNIT, code, 0, code.length(), 0, String.valueOf('\n'));
 		//Document doc= new Document(code);
 		//edit.apply(doc, 0);
 		//String res= doc.get();

 		// old formatter
 		String res= ToolFactory.createDefaultCodeFormatter(options).format(code, 0, null, String.valueOf('\n'));
 		System.out.print(res);
 	}

 	public void createPropertyList(Class[] astClases, StringBuffer buf) throws Exception {
 		HashMap properties= getPropertyList(astClases);

 		Object[] objects= properties.keySet().toArray();
 		Arrays.sort(objects, Collator.getInstance());
 		for (int i= 0; i < objects.length; i++) {
 			String curr= (String) objects[i];

 			buf.append("/**\n");
 			buf.append(" * Property for nodes of type\n");
 			List parents= (List) properties.get(curr);
 			Collections.sort(parents, new ClassNameComparer());
 			int lastParent= parents.size() - 1;
 			for (int k= 0; k <= lastParent; k++) {
 				Class parent= (Class) parents.get(k);
 				buf.append(" * <code>" + Signature.getSimpleName(parent.getName()) + "</code>");
 				if (k != lastParent) {
 					buf.append(",\n");
 				} else {
 					buf.append(".\n");
 				}
 			}
 			buf.append(" */\n");
 			buf.append("public static final int " + curr + "= " + String.valueOf(i + 1) + ";\n\n");
 		}
 	}

 	public void createPropertyValidator(Class[] astClases, StringBuffer buf) throws Exception {
 		HashMap classes= createClassList(astClases);

 		buf.append("\n/**");
 		buf.append("\n *Returns <code>true</code> if a node has the given property.");
 		buf.append("\n */\n");
 		buf.append("public static boolean hasChildProperty(ASTNode node, int property) {");
 		buf.append("switch (node.getNodeType()) {");

 		Object[] objects= classes.keySet().toArray();
 		Arrays.sort(objects, new ClassNameComparer());
 		for (int i= 0; i < objects.length; i++) {
 			Class curr= (Class) objects[i];
 			Object[] properties= ((List) classes.get(curr)).toArray();
 			Arrays.sort(properties, Collator.getInstance());

 			int nProperties= properties.length;
 			if (nProperties != 0) {
 				String name= Signature.getSimpleName(curr.getName());
 				buf.append("case ASTNode." + toConstantName(name) + ":");
 				if (nProperties == 1) {
 					buf.append("return property == " +properties[0] + ";");
 				} else if (nProperties == 2) {
 					buf.append("return (property == " +properties[0] + ") || (property == " +properties[1] + ");");
 				} else if (nProperties == 3) {
 					buf.append("return (property == " +properties[0] + ") || (property == " +properties[1] + ") || (property == " +properties[2] + ");");
 				} else {
 					buf.append("switch (property) {");
 					for (int k= 0; k < nProperties; k++) {
 						buf.append("case " + properties[k] + ":");
 					}
 					buf.append("return true;");
 					buf.append("}");
 					buf.append("return false;");
 				}
 			}
 		}
 		buf.append("}");
 		buf.append("return false;");
 		buf.append("}\n\n");
 	}

 	public void createIsListTest(Class[] astClases, StringBuffer buf) throws Exception {

 		HashSet listProperties= new HashSet();
 		HashSet otherProperties= new HashSet();

 		for (int i= 0; i < astClases.length; i++) {
 			Class cl= astClases[i];
 			Method[] properties= getProperties(cl);
 			for (int k= 0; k < properties.length; k++) {
 				Method curr= properties[k];
 				Class ret= curr.getReturnType();

 				String name= toConstantName(getPropertyName(curr));
 				if (!LIST.equals(ret.getName())) {
 					otherProperties.add(name);
 					if (listProperties.contains(name)) {
 						System.err.println("Property is list and non-list: " + name);
 					}
 					if (!fgASTFilter.accept(ret) && !fgPrimitiveFilter.accept(ret)) {
 						System.err.println("Property has unknown return type: " + ret.getName());
 					}
 				} else {
 					if (otherProperties.contains(name)) {
 						System.err.println("Property is list and non-list: " + name);
 					} else {
 						listProperties.add(name);
 					}
 				}
 			}
 		}

 		String[] lists= (String[]) listProperties.toArray(new String[listProperties.size()]);
 		Arrays.sort(lists, Collator.getInstance());

 		buf.append("\n/**");
 		buf.append("\n  * Returns <code>true</code> if property of a node is a list property.");
 		buf.append("\n */\n");
 		buf.append("public static boolean isListProperty(int property) {");
 		buf.append("switch (property) {");

 		for (int i= 0; i < lists.length; i++) {
 			buf.append("case " + lists[i] + ":");
 		}
 		buf.append("return true;");
 		buf.append("}");
 		buf.append("return false;");
 		buf.append("}\n\n");
 	}

 	public void createIsAttributeTest(Class[] astClases, StringBuffer buf) throws Exception {

 		HashSet otherProperties= new HashSet();
 		HashSet attribProperties= new HashSet();

 		for (int i= 0; i < astClases.length; i++) {
 			Class cl= astClases[i];
 			Method[] properties= getProperties(cl);
 			for (int k= 0; k < properties.length; k++) {
 				Method curr= properties[k];
 				Class ret= curr.getReturnType();

 				String name= toConstantName(getPropertyName(curr));
 				if (fgPrimitiveFilter.accept(ret)) {
 					attribProperties.add(name);
 					if (otherProperties.contains(name)) {
 						System.err.println("Property is attribute and non-attribute: " + name);
 					}
 				} else {
 					if (attribProperties.contains(name)) {
 						System.err.println("Property is attribute and non-attribute: " + name);
 					} else {
 						otherProperties.add(name);
 					}
 				}
 			}
 		}

 		String[] lists= (String[]) attribProperties.toArray(new String[attribProperties.size()]);
 		Arrays.sort(lists, Collator.getInstance());

 		buf.append("\n/**");
 		buf.append("\n  * Returns <code>true</code> if property of a node is an attribute property (Not a List and not an ASTNode).");
 		buf.append("\n */\n");
 		buf.append("public static boolean isAttributeProperty(int property) {");
 		buf.append("switch (property) {");

 		for (int i= 0; i < lists.length; i++) {
 			buf.append("case " + lists[i] + ":");
 		}
 		buf.append("return true;");
 		buf.append("}");
 		buf.append("return false;");
 		buf.append("}\n\n");
 	}


 	public void createListAccessor(Class[] astClases, StringBuffer buf) throws Exception {

 		buf.append("\n/**");
 		buf.append("\n * Gets a property in a list.");
 		buf.append("\n */\n");
 		buf.append("public static ASTNode getNodeChild(ASTNode node, int property, int index) {");
 		buf.append("if (!isListProperty(property)) {");
 		buf.append("throw new IllegalArgumentException();");
 		buf.append("}");
 		buf.append("return (ASTNode) ((List) getNodeChild(node, property)).get(index);");
 		buf.append("}\n\n");

 	}


 	public void createGetNodeChild(Class[] astClases, StringBuffer buf) throws Exception {


 		buf.append("\n/**");
 		buf.append("\n * Gets a ASTNode child by the property id. Booleans and integer attributes are returned boxed.");
 		buf.append("\n */\n");
 		buf.append("public static Object getNodeChild(ASTNode node, int property) {");
 		buf.append("switch (node.getNodeType()) {");

 		for (int i= 0; i < astClases.length; i++) {
 			Class curr= astClases[i];
 			Method[] properties= getProperties(curr, fgNoFilter);

 			int nProperties= properties.length;
 			if (nProperties != 0) {
 				String className= Signature.getSimpleName(curr.getName());
 				buf.append("case ASTNode." + toConstantName(className) + ":");

 				if (nProperties == 1) {
 					String name= getPropertyName(properties[0]);

 					buf.append("if (property == " + toConstantName(name) + ") {");
 					appendWrapped(buf, className, properties[0]);
 					buf.append("}");
 					buf.append("break;");
 				} else {
 					Arrays.sort(properties, new MethodNameComparer());

 					buf.append("switch (property) {");
 					for (int k= 0; k < nProperties; k++) {

 						Method meth= properties[k];
 						String name= getPropertyName(meth);
 						buf.append("case " + toConstantName(name) + ":");
 						appendWrapped(buf, className, meth);
 					}
 					buf.append("}");
 					buf.append("break;");
 				}
 			}
 		}
 		buf.append("}");
 		buf.append("throw new IllegalArgumentException();");
 		buf.append("}\n\n");
 	}


 	private void appendWrapped(StringBuffer buf, String className, Method meth) {
 		buf.append("return ");
 		String val= "((" + className + ") node)." + meth.getName() + "()";

 		String retType= meth.getReturnType().getName();
 		if ("int".equals(retType)) {
 			buf.append("new Integer(");
 			buf.append(val);
 			buf.append(")");
 		} else if ("boolean".equals(retType)){
 			buf.append("new Boolean(");
 			buf.append(val);
 			buf.append(")");
 		} else {
 			buf.append(val);
 		}
 		buf.append(";");
 	}

 	public void createGetPropertyOfNode(Class[] astClases, StringBuffer buf) throws Exception {

 		buf.append("\n/**");
 		buf.append("\n * Gets the child property a node is located at its parent.");
 		buf.append("\n */\n");
 		buf.append("public static int getPropertyOfNode(ASTNode node) {");
 		buf.append("ASTNode parent=node.getParent();");
 		buf.append("if (parent == null) {");
 		buf.append("throw new IllegalArgumentException();");
 		buf.append("}");

 		buf.append("switch (parent.getNodeType()) {");

 		MethodTypeComparer comparer= new MethodTypeComparer();

 		for (int i= 0; i < astClases.length; i++) {
 			Class curr= astClases[i];
 			Method[] properties= getProperties(curr, fgListAndASTFilter);

 			int nProperties= properties.length;
 			if (nProperties != 0) {
 				String className= Signature.getSimpleName(curr.getName());
 				buf.append("case ASTNode." + toConstantName(className) + ":");
 				String varName= "((" + className + ") parent)";
 				if (nProperties > 2) {
 					varName= toVariableName(className);
 					buf.append(className);
 					buf.append(" ");
 					buf.append(varName);
 					buf.append("=(");
 					buf.append(className);
 					buf.append(")parent;");
 				}
 				Arrays.sort(properties, comparer);
 				for (int k= 0; k < properties.length; k++) {
 					Method meth= properties[k];
 					if (k != properties.length - 1) {
 						buf.append("if (").append(varName).append(".");
 						buf.append(meth.getName());
 						if (LIST.equals(meth.getReturnType().getName())) {
 							buf.append("().contains(node))");
 						} else {
 							buf.append("() == node)");
 						}
 					}
 					buf.append("return ");
 					buf.append(toConstantName(getPropertyName(meth)));
 					buf.append(";");
 				}
 			}
 		}
 		buf.append("}");
 		buf.append("throw new IllegalArgumentException();");
 		buf.append("}\n\n");
 	}

 	public void createGetNodeChildProperties(Class[] astClases, StringBuffer buf) throws Exception {

 		buf.append("\n/**");
 		buf.append("\n * Returns the properties of all children.");
 		buf.append("\n */\n");
 		buf.append("public static int[] getNodeChildProperties(ASTNode node) {");

 		buf.append("switch (node.getNodeType()) {");

 		for (int i= 0; i < astClases.length; i++) {
 			Class curr= astClases[i];
 			Method[] properties= getProperties(curr, fgNoFilter);

 			int nProperties= properties.length;
 			if (nProperties != 0) {
 				String className= Signature.getSimpleName(curr.getName());
 				buf.append("case ASTNode." + toConstantName(className) + ":");
 				buf.append("return new int[] {");
 				for (int k= 0; k < properties.length; k++) {
 					if (k > 0) {
 						buf.append(",");
 					}
 					buf.append(toConstantName(getPropertyName(properties[k])));
 				}
 				buf.append("};");
 			}
 		}
 		buf.append("}");
 		buf.append("return new int[0];");
 		buf.append("}\n\n");
 	}

 	private void createGetChildPropertyName(Class[] astClases, StringBuffer buf) {
 		HashSet result= new HashSet();
 		for (int i= 0; i < astClases.length; i++) {
 			Class cl= astClases[i];
 			Method[] properties= getProperties(cl);
 			for (int k= 0; k < properties.length; k++) {
 				Method curr= properties[k];
 				String name= getPropertyName(curr);
 				result.add(name);
 			}
 		}
 		Object[] properties= result.toArray();
 		Arrays.sort(properties, Collator.getInstance());

 		buf.append("\n/**");
 		buf.append("\n * Returns the name of a property.");
 		buf.append("\n */\n");
 		buf.append("public static String getPropertyName(int property) {");

 		buf.append("switch (property) {");

 		for (int i= 0; i < properties.length; i++) {
 			String curr= toConstantName((String) properties[i]);

 			buf.append("case " + curr + ":");
 			buf.append("return ").append('"').append(curr).append('"').append("; //$NON-NLS-1$\n");
 		}
 		buf.append("}");
 		buf.append("throw new IllegalArgumentException();");
 		buf.append("}\n\n");
 	}


 	private HashMap getPropertyList(Class[] astClases) {
 		HashMap result= new HashMap();
 		for (int i= 0; i < astClases.length; i++) {
 			Class cl= astClases[i];
 			Method[] properties= getProperties(cl);
 			for (int k= 0; k < properties.length; k++) {
 				Method curr= properties[k];
 				String name= getPropertyName(curr);
 				addToListMap(result, toConstantName(name), cl);
 			}
 		}
 		return result;
 	}

 	private HashMap createClassList(Class[] astClases) {
 		HashMap result= new HashMap();
 		for (int i= 0; i < astClases.length; i++) {
 			Class cl= astClases[i];
 			Method[] properties= getProperties(cl);
 			for (int k= 0; k < properties.length; k++) {
 				Method curr= properties[k];
 				String name= getPropertyName(curr);
 				addToListMap(result, cl, toConstantName(name));
 			}
 		}
 		return result;
 	}

 	private static String getPropertyName(Method curr) {
 		String name= curr.getName();
 		if (name.startsWith("get")) {
 			return name.substring(3);
 		} else if (name.startsWith("is")) {
 			return name;
 		}
 		return name;
 	}


 	private void addToListMap(HashMap properties, Object key, Object value) {
 		ArrayList list= (ArrayList) properties.get(key);
 		if (list == null) {
 			list= new ArrayList(3);
 			properties.put(key, list);
 		}
 		list.add(value);
 	}


 	private static Class[] getASTClasses() {
 		ArrayList list= new ArrayList();
 		Class class1= ASTVisitor.class;
 		Method[] methods= class1.getMethods();
 		for (int i= 0; i < methods.length; i++) {
 			Method curr= methods[i];
 			if ("visit".equals(curr.getName())) {
 				Class param= curr.getParameterTypes()[0];
 				list.add(param);
 			}
 		}
 		return (Class[]) list.toArray(new Class[list.size()]);
 	}

 	private static Method[] getProperties(Class param) {
 		return getProperties(param, fgNoFilter);
 	}

 	private static Method[] getProperties(Class param, TypeFilter filter) {
 		ArrayList res= new ArrayList();
 		Method[] methods= param.getMethods();
 		for (int i= 0; i < methods.length; i++) {
 			Method curr= methods[i];
 			int modifiers= curr.getModifiers();
 			if ((modifiers & (Modifier.STATIC | Modifier.PUBLIC)) == Modifier.PUBLIC) {
 				String name= curr.getName();
 				if (!fgPropertyIgnoreList.contains(name)) {
 					Class returnType= curr.getReturnType();
 					if (returnType.isArray()) {
 						continue;
 					}

 					if (LIST.equals(returnType.getName())) {
 						if (filter.accept(returnType) ) {
 							res.add(curr);
 						}
 					} else if (name.startsWith("set")) {
 						Method getter= findGetter(methods, name.substring(3));
 						if (getter != null && filter.accept(getter.getReturnType())) {
 							res.add(getter);
 						}
 					}
 				}
 			}
 		}
 		return (Method[]) res.toArray(new Method[res.size()]);
 	}

 	private static Method findGetter(Method[] methods, String string) {
 		String s1= "get" + string;
 		String s2= "is" + string;
 		for (int i= 0; i < methods.length; i++) {
 			String name= methods[i].getName();
 			if (s1.equals(name) || s2.equals(name)) {
 				return methods[i];
 			}
 		}
 		return null;
 	}

 	private static String toConstantName(String string) {
 		StringBuffer buf= new StringBuffer();
 		for (int i= 0; i < string.length(); i++) {
 			char ch= string.charAt(i);
 			if (i != 0 && Character.isUpperCase(ch)) {
 				buf.append('_');
 			}
 			buf.append(Character.toUpperCase(ch));
 		}
 		return buf.toString();
 	}

 	private static String toVariableName(String string) {
 		return Character.toLowerCase(string.charAt(0)) + string.substring(1);
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2000, 2003 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Common Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/cpl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.ui.examples;

	import java.lang.reflect.Method;
	import java.lang.reflect.Modifier;
	import java.text.Collator;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Hashtable;
	import java.util.List;

	import junit.framework.Test;
	import junit.framework.TestCase;
	import junit.framework.TestSuite;

	import org.eclipse.jdt.core.JavaCore;
	import org.eclipse.jdt.core.Signature;
	import org.eclipse.jdt.core.ToolFactory;
	import org.eclipse.jdt.core.dom.ASTNode;
	import org.eclipse.jdt.core.dom.ASTVisitor;

	/**
	*
	*/
	public class ASTChildConstantsGenerator extends TestCase {

	private static final String LIST= "java.util.List";

	public static TypeFilter fgListFilter= new NodeTypeFilter(List.class);
	public static TypeFilter fgASTFilter= new NodeTypeFilter(ASTNode.class);
	public static TypeFilter fgListAndASTFilter= new PrimitiveTypeFilter(true);
	public static TypeFilter fgPrimitiveFilter= new PrimitiveTypeFilter(false);
	public static TypeFilter fgNoFilter= new TypeFilter();

	public static class TypeFilter {
	public boolean accept(Class returnType) {
	return true;
	}
	}

	public static class NodeTypeFilter extends TypeFilter {
	private Class fClass;

	public NodeTypeFilter(Class cl) {
	fClass= cl;
	}

	public boolean accept(Class returnType) {
	return fClass.isAssignableFrom(returnType);
	}
	}

	public static class PrimitiveTypeFilter extends TypeFilter {

	private boolean fInvert;

	public PrimitiveTypeFilter(boolean b) {
	fInvert= b;
	}

	public boolean accept(Class returnType) {
	return fInvert ^ (!LIST.equals(returnType.getName()) && !ASTNode.class.isAssignableFrom(returnType));
	}
	}


	public class ClassNameComparer implements Comparator {

	private Collator fCollator= Collator.getInstance();

	public int compare(Object o1, Object o2) {
	String name1= ((Class)o1).getName();
	String name2= ((Class)o2).getName();
	return fCollator.compare(name1, name2);
	}

	}

	public class MethodNameComparer implements Comparator {

	private Collator fCollator= Collator.getInstance();

	public int compare(Object o1, Object o2) {
	String name1= ((Method)o1).getName();
	String name2= ((Method)o2).getName();
	return fCollator.compare(name1, name2);
	}

	}

	public class MethodTypeComparer implements Comparator {

	private Collator fCollator= Collator.getInstance();

	public int compare(Object o1, Object o2) {
	Method m1= (Method)o1;
	Method m2= (Method)o2;
	boolean isList1= LIST.equals(m1.getReturnType().getName());
	boolean isList2= LIST.equals(m2.getReturnType().getName());
	if (isList1 && !isList2) {
	return 1;
	} else if (!isList1 && isList2) {
	return -1;
	}
	String name1= m1.getName();
	String name2= m2.getName();
	return fCollator.compare(name1, name2);
	}

	}

	private static final Class THIS= ASTChildConstantsGenerator.class;

	private static HashSet fgPropertyIgnoreList;

	static {
	fgPropertyIgnoreList= new HashSet();
	fgPropertyIgnoreList.add("setProperty");
	fgPropertyIgnoreList.add("setParent");
	fgPropertyIgnoreList.add("setFlags");
	fgPropertyIgnoreList.add("setLeadingComment");
	}


	public ASTChildConstantsGenerator(String name) {
	super(name);



	}

	public static Test allTests() {
	return new TestSuite(THIS);
	}

	public static Test suite() {
	if (false) {
	return allTests();
	} else {
	TestSuite suite= new TestSuite();
	suite.addTest(new ASTChildConstantsGenerator("createGeneratedCU"));
	return suite;
	}
	}

	protected void setUp() throws Exception {
	}


	protected void tearDown() throws Exception {
	}


	public void createGeneratedCU() throws Exception {

	Class[] astClases= getASTClasses();
	Arrays.sort(astClases, new ClassNameComparer());

	StringBuffer buf= new StringBuffer();
	buf.append("package org.eclipse.jdt.internal.corext.dom;\n\n");
	buf.append("import java.util.List;");
	buf.append("import org.eclipse.jdt.core.dom.*;\n\n");
	buf.append("public class ASTNodeConstants {\n");

	createPropertyList(astClases, buf);
	createPropertyValidator(astClases, buf);
	createIsListTest(astClases, buf);
	createIsAttributeTest(astClases, buf);
	createListAccessor(astClases, buf);
	createGetNodeChild(astClases, buf);
	createGetPropertyOfNode(astClases, buf);
	createGetNodeChildProperties(astClases, buf);
	createGetChildPropertyName(astClases, buf);

	buf.append("}");

	String code= buf.toString();

	Hashtable options= JavaCore.getOptions();
	options.put(JavaCore.FORMATTER_LINE_SPLIT, "999");

	// new formatter
	//TextEdit edit= ToolFactory.createCodeFormatter(options).format(CodeFormatter.K_COMPILATION_UNIT, code, 0, code.length(), 0, String.valueOf('\n'));
	//Document doc= new Document(code);
	//edit.apply(doc, 0);
	//String res= doc.get();

	// old formatter
	String res= ToolFactory.createDefaultCodeFormatter(options).format(code, 0, null, String.valueOf('\n'));
	System.out.print(res);
	}

	public void createPropertyList(Class[] astClases, StringBuffer buf) throws Exception {
	HashMap properties= getPropertyList(astClases);

	Object[] objects= properties.keySet().toArray();
	Arrays.sort(objects, Collator.getInstance());
	for (int i= 0; i < objects.length; i++) {
	String curr= (String) objects[i];

	buf.append("/**\n");
	buf.append(" * Property for nodes of type\n");
	List parents= (List) properties.get(curr);
	Collections.sort(parents, new ClassNameComparer());
	int lastParent= parents.size() - 1;
	for (int k= 0; k <= lastParent; k++) {
	Class parent= (Class) parents.get(k);
	buf.append(" * <code>" + Signature.getSimpleName(parent.getName()) + "</code>");
	if (k != lastParent) {
	buf.append(",\n");
	} else {
	buf.append(".\n");
	}
	}
	buf.append(" */\n");
	buf.append("public static final int " + curr + "= " + String.valueOf(i + 1) + ";\n\n");
	}
	}

	public void createPropertyValidator(Class[] astClases, StringBuffer buf) throws Exception {
	HashMap classes= createClassList(astClases);

	buf.append("\n/**");
	buf.append("\n *Returns <code>true</code> if a node has the given property.");
	buf.append("\n */\n");
	buf.append("public static boolean hasChildProperty(ASTNode node, int property) {");
	buf.append("switch (node.getNodeType()) {");

	Object[] objects= classes.keySet().toArray();
	Arrays.sort(objects, new ClassNameComparer());
	for (int i= 0; i < objects.length; i++) {
	Class curr= (Class) objects[i];
	Object[] properties= ((List) classes.get(curr)).toArray();
	Arrays.sort(properties, Collator.getInstance());

	int nProperties= properties.length;
	if (nProperties != 0) {
	String name= Signature.getSimpleName(curr.getName());
	buf.append("case ASTNode." + toConstantName(name) + ":");
	if (nProperties == 1) {
	buf.append("return property == " +properties[0] + ";");
	} else if (nProperties == 2) {
	buf.append("return (property == " +properties[0] + ") \|\| (property == " +properties[1] + ");");
	} else if (nProperties == 3) {
	buf.append("return (property == " +properties[0] + ") \|\| (property == " +properties[1] + ") \|\| (property == " +properties[2] + ");");
	} else {
	buf.append("switch (property) {");
	for (int k= 0; k < nProperties; k++) {
	buf.append("case " + properties[k] + ":");
	}
	buf.append("return true;");
	buf.append("}");
	buf.append("return false;");
	}
	}
	}
	buf.append("}");
	buf.append("return false;");
	buf.append("}\n\n");
	}

	public void createIsListTest(Class[] astClases, StringBuffer buf) throws Exception {

	HashSet listProperties= new HashSet();
	HashSet otherProperties= new HashSet();

	for (int i= 0; i < astClases.length; i++) {
	Class cl= astClases[i];
	Method[] properties= getProperties(cl);
	for (int k= 0; k < properties.length; k++) {
	Method curr= properties[k];
	Class ret= curr.getReturnType();

	String name= toConstantName(getPropertyName(curr));
	if (!LIST.equals(ret.getName())) {
	otherProperties.add(name);
	if (listProperties.contains(name)) {
	System.err.println("Property is list and non-list: " + name);
	}
	if (!fgASTFilter.accept(ret) && !fgPrimitiveFilter.accept(ret)) {
	System.err.println("Property has unknown return type: " + ret.getName());
	}
	} else {
	if (otherProperties.contains(name)) {
	System.err.println("Property is list and non-list: " + name);
	} else {
	listProperties.add(name);
	}
	}
	}
	}

	String[] lists= (String[]) listProperties.toArray(new String[listProperties.size()]);
	Arrays.sort(lists, Collator.getInstance());

	buf.append("\n/**");
	buf.append("\n * Returns <code>true</code> if property of a node is a list property.");
	buf.append("\n */\n");
	buf.append("public static boolean isListProperty(int property) {");
	buf.append("switch (property) {");

	for (int i= 0; i < lists.length; i++) {
	buf.append("case " + lists[i] + ":");
	}
	buf.append("return true;");
	buf.append("}");
	buf.append("return false;");
	buf.append("}\n\n");
	}

	public void createIsAttributeTest(Class[] astClases, StringBuffer buf) throws Exception {

	HashSet otherProperties= new HashSet();
	HashSet attribProperties= new HashSet();

	for (int i= 0; i < astClases.length; i++) {
	Class cl= astClases[i];
	Method[] properties= getProperties(cl);
	for (int k= 0; k < properties.length; k++) {
	Method curr= properties[k];
	Class ret= curr.getReturnType();

	String name= toConstantName(getPropertyName(curr));
	if (fgPrimitiveFilter.accept(ret)) {
	attribProperties.add(name);
	if (otherProperties.contains(name)) {
	System.err.println("Property is attribute and non-attribute: " + name);
	}
	} else {
	if (attribProperties.contains(name)) {
	System.err.println("Property is attribute and non-attribute: " + name);
	} else {
	otherProperties.add(name);
	}
	}
	}
	}

	String[] lists= (String[]) attribProperties.toArray(new String[attribProperties.size()]);
	Arrays.sort(lists, Collator.getInstance());

	buf.append("\n/**");
	buf.append("\n * Returns <code>true</code> if property of a node is an attribute property (Not a List and not an ASTNode).");
	buf.append("\n */\n");
	buf.append("public static boolean isAttributeProperty(int property) {");
	buf.append("switch (property) {");

	for (int i= 0; i < lists.length; i++) {
	buf.append("case " + lists[i] + ":");
	}
	buf.append("return true;");
	buf.append("}");
	buf.append("return false;");
	buf.append("}\n\n");
	}


	public void createListAccessor(Class[] astClases, StringBuffer buf) throws Exception {

	buf.append("\n/**");
	buf.append("\n * Gets a property in a list.");
	buf.append("\n */\n");
	buf.append("public static ASTNode getNodeChild(ASTNode node, int property, int index) {");
	buf.append("if (!isListProperty(property)) {");
	buf.append("throw new IllegalArgumentException();");
	buf.append("}");
	buf.append("return (ASTNode) ((List) getNodeChild(node, property)).get(index);");
	buf.append("}\n\n");

	}




	public void createGetNodeChild(Class[] astClases, StringBuffer buf) throws Exception {


	buf.append("\n/**");
	buf.append("\n * Gets a ASTNode child by the property id. Booleans and integer attributes are returned boxed.");
	buf.append("\n */\n");
	buf.append("public static Object getNodeChild(ASTNode node, int property) {");
	buf.append("switch (node.getNodeType()) {");

	for (int i= 0; i < astClases.length; i++) {
	Class curr= astClases[i];
	Method[] properties= getProperties(curr, fgNoFilter);

	int nProperties= properties.length;
	if (nProperties != 0) {
	String className= Signature.getSimpleName(curr.getName());
	buf.append("case ASTNode." + toConstantName(className) + ":");

	if (nProperties == 1) {
	String name= getPropertyName(properties[0]);

	buf.append("if (property == " + toConstantName(name) + ") {");
	appendWrapped(buf, className, properties[0]);
	buf.append("}");
	buf.append("break;");
	} else {
	Arrays.sort(properties, new MethodNameComparer());

	buf.append("switch (property) {");
	for (int k= 0; k < nProperties; k++) {

	Method meth= properties[k];
	String name= getPropertyName(meth);
	buf.append("case " + toConstantName(name) + ":");
	appendWrapped(buf, className, meth);
	}
	buf.append("}");
	buf.append("break;");
	}
	}
	}
	buf.append("}");
	buf.append("throw new IllegalArgumentException();");
	buf.append("}\n\n");
	}




	private void appendWrapped(StringBuffer buf, String className, Method meth) {
	buf.append("return ");
	String val= "((" + className + ") node)." + meth.getName() + "()";

	String retType= meth.getReturnType().getName();
	if ("int".equals(retType)) {
	buf.append("new Integer(");
	buf.append(val);
	buf.append(")");
	} else if ("boolean".equals(retType)){
	buf.append("new Boolean(");
	buf.append(val);
	buf.append(")");
	} else {
	buf.append(val);
	}
	buf.append(";");
	}

	public void createGetPropertyOfNode(Class[] astClases, StringBuffer buf) throws Exception {

	buf.append("\n/**");
	buf.append("\n * Gets the child property a node is located at its parent.");
	buf.append("\n */\n");
	buf.append("public static int getPropertyOfNode(ASTNode node) {");
	buf.append("ASTNode parent=node.getParent();");
	buf.append("if (parent == null) {");
	buf.append("throw new IllegalArgumentException();");
	buf.append("}");

	buf.append("switch (parent.getNodeType()) {");

	MethodTypeComparer comparer= new MethodTypeComparer();

	for (int i= 0; i < astClases.length; i++) {
	Class curr= astClases[i];
	Method[] properties= getProperties(curr, fgListAndASTFilter);

	int nProperties= properties.length;
	if (nProperties != 0) {
	String className= Signature.getSimpleName(curr.getName());
	buf.append("case ASTNode." + toConstantName(className) + ":");
	String varName= "((" + className + ") parent)";
	if (nProperties > 2) {
	varName= toVariableName(className);
	buf.append(className);
	buf.append(" ");
	buf.append(varName);
	buf.append("=(");
	buf.append(className);
	buf.append(")parent;");
	}
	Arrays.sort(properties, comparer);
	for (int k= 0; k < properties.length; k++) {
	Method meth= properties[k];
	if (k != properties.length - 1) {
	buf.append("if (").append(varName).append(".");
	buf.append(meth.getName());
	if (LIST.equals(meth.getReturnType().getName())) {
	buf.append("().contains(node))");
	} else {
	buf.append("() == node)");
	}
	}
	buf.append("return ");
	buf.append(toConstantName(getPropertyName(meth)));
	buf.append(";");
	}
	}
	}
	buf.append("}");
	buf.append("throw new IllegalArgumentException();");
	buf.append("}\n\n");
	}

	public void createGetNodeChildProperties(Class[] astClases, StringBuffer buf) throws Exception {

	buf.append("\n/**");
	buf.append("\n * Returns the properties of all children.");
	buf.append("\n */\n");
	buf.append("public static int[] getNodeChildProperties(ASTNode node) {");

	buf.append("switch (node.getNodeType()) {");

	for (int i= 0; i < astClases.length; i++) {
	Class curr= astClases[i];
	Method[] properties= getProperties(curr, fgNoFilter);

	int nProperties= properties.length;
	if (nProperties != 0) {
	String className= Signature.getSimpleName(curr.getName());
	buf.append("case ASTNode." + toConstantName(className) + ":");
	buf.append("return new int[] {");
	for (int k= 0; k < properties.length; k++) {
	if (k > 0) {
	buf.append(",");
	}
	buf.append(toConstantName(getPropertyName(properties[k])));
	}
	buf.append("};");
	}
	}
	buf.append("}");
	buf.append("return new int[0];");
	buf.append("}\n\n");
	}

	private void createGetChildPropertyName(Class[] astClases, StringBuffer buf) {
	HashSet result= new HashSet();
	for (int i= 0; i < astClases.length; i++) {
	Class cl= astClases[i];
	Method[] properties= getProperties(cl);
	for (int k= 0; k < properties.length; k++) {
	Method curr= properties[k];
	String name= getPropertyName(curr);
	result.add(name);
	}
	}
	Object[] properties= result.toArray();
	Arrays.sort(properties, Collator.getInstance());

	buf.append("\n/**");
	buf.append("\n * Returns the name of a property.");
	buf.append("\n */\n");
	buf.append("public static String getPropertyName(int property) {");

	buf.append("switch (property) {");

	for (int i= 0; i < properties.length; i++) {
	String curr= toConstantName((String) properties[i]);

	buf.append("case " + curr + ":");
	buf.append("return ").append('"').append(curr).append('"').append("; //$NON-NLS-1$\n");
	}
	buf.append("}");
	buf.append("throw new IllegalArgumentException();");
	buf.append("}\n\n");
	}


	private HashMap getPropertyList(Class[] astClases) {
	HashMap result= new HashMap();
	for (int i= 0; i < astClases.length; i++) {
	Class cl= astClases[i];
	Method[] properties= getProperties(cl);
	for (int k= 0; k < properties.length; k++) {
	Method curr= properties[k];
	String name= getPropertyName(curr);
	addToListMap(result, toConstantName(name), cl);
	}
	}
	return result;
	}

	private HashMap createClassList(Class[] astClases) {
	HashMap result= new HashMap();
	for (int i= 0; i < astClases.length; i++) {
	Class cl= astClases[i];
	Method[] properties= getProperties(cl);
	for (int k= 0; k < properties.length; k++) {
	Method curr= properties[k];
	String name= getPropertyName(curr);
	addToListMap(result, cl, toConstantName(name));
	}
	}
	return result;
	}

	private static String getPropertyName(Method curr) {
	String name= curr.getName();
	if (name.startsWith("get")) {
	return name.substring(3);
	} else if (name.startsWith("is")) {
	return name;
	}
	return name;
	}


	private void addToListMap(HashMap properties, Object key, Object value) {
	ArrayList list= (ArrayList) properties.get(key);
	if (list == null) {
	list= new ArrayList(3);
	properties.put(key, list);
	}
	list.add(value);
	}


	private static Class[] getASTClasses() {
	ArrayList list= new ArrayList();
	Class class1= ASTVisitor.class;
	Method[] methods= class1.getMethods();
	for (int i= 0; i < methods.length; i++) {
	Method curr= methods[i];
	if ("visit".equals(curr.getName())) {
	Class param= curr.getParameterTypes()[0];
	list.add(param);
	}
	}
	return (Class[]) list.toArray(new Class[list.size()]);
	}

	private static Method[] getProperties(Class param) {
	return getProperties(param, fgNoFilter);
	}

	private static Method[] getProperties(Class param, TypeFilter filter) {
	ArrayList res= new ArrayList();
	Method[] methods= param.getMethods();
	for (int i= 0; i < methods.length; i++) {
	Method curr= methods[i];
	int modifiers= curr.getModifiers();
	if ((modifiers & (Modifier.STATIC \| Modifier.PUBLIC)) == Modifier.PUBLIC) {
	String name= curr.getName();
	if (!fgPropertyIgnoreList.contains(name)) {
	Class returnType= curr.getReturnType();
	if (returnType.isArray()) {
	continue;
	}

	if (LIST.equals(returnType.getName())) {
	if (filter.accept(returnType) ) {
	res.add(curr);
	}
	} else if (name.startsWith("set")) {
	Method getter= findGetter(methods, name.substring(3));
	if (getter != null && filter.accept(getter.getReturnType())) {
	res.add(getter);
	}
	}
	}
	}
	}
	return (Method[]) res.toArray(new Method[res.size()]);
	}

	private static Method findGetter(Method[] methods, String string) {
	String s1= "get" + string;
	String s2= "is" + string;
	for (int i= 0; i < methods.length; i++) {
	String name= methods[i].getName();
	if (s1.equals(name) \|\| s2.equals(name)) {
	return methods[i];
	}
	}
	return null;
	}

	private static String toConstantName(String string) {
	StringBuffer buf= new StringBuffer();
	for (int i= 0; i < string.length(); i++) {
	char ch= string.charAt(i);
	if (i != 0 && Character.isUpperCase(ch)) {
	buf.append('_');
	}
	buf.append(Character.toUpperCase(ch));
	}
	return buf.toString();
	}

	private static String toVariableName(String string) {
	return Character.toLowerCase(string.charAt(0)) + string.substring(1);
	}

	}