Merge pull request #1 from rzwitserloot/master

merge from the main repo

3 files changed, 55 insertions, 25 deletions

diff --git a/src/core/lombok/core/AST.java b/src/core/lombok/core/AST.java
index e6efe058..1142018f 100644
--- a/src/core/lombok/core/AST.java
+++ b/src/core/lombok/core/AST.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2013 The Project Lombok Authors.
+ * Copyright (C) 2009-2016 The Project Lombok Authors.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -21,7 +21,7 @@
  */
 package lombok.core;
 
-import static lombok.Lombok.*;
+import static lombok.Lombok.sneakyThrow;
 
 import java.lang.reflect.Array;
 import java.lang.reflect.Field;
@@ -31,10 +31,11 @@ import java.lang.reflect.Type;
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.HashMap;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 
 import lombok.core.configuration.ConfigurationKey;
 import lombok.core.debug.HistogramTracker;
@@ -61,12 +62,18 @@ public abstract class AST<A extends AST<A, L, N>, L extends LombokNode<A, L, N>,
 	Map<N, N> identityDetector = new IdentityHashMap<N, N>();
 	private Map<N, L> nodeMap = new IdentityHashMap<N, L>();
 	private boolean changed = false;
+	
+	// The supertypes which are considered AST Node children. Usually, the Statement, and the Expression,
+	// though some platforms (such as Eclipse) group these under one common supertype.
+	private final Collection<Class<? extends N>> statementTypes;
+	
 	private static final HistogramTracker configTracker = System.getProperty("lombok.timeConfig") == null ? null : new HistogramTracker("lombok.config");
 	
-	protected AST(String fileName, String packageDeclaration, ImportList imports) {
+	protected AST(String fileName, String packageDeclaration, ImportList imports, Collection<Class<? extends N>> statementTypes) {
 		this.fileName = fileName == null ? "(unknown).java" : fileName;
 		this.packageDeclaration = packageDeclaration;
 		this.imports = imports;
+		this.statementTypes = statementTypes;
 	}
 	
 	/**
@@ -209,11 +216,11 @@ public abstract class AST<A extends AST<A, L, N>, L extends LombokNode<A, L, N>,
 		}
 	}
 	
-	private static Map<Class<?>, Collection<FieldAccess>> fieldsOfASTClasses = new HashMap<Class<?>, Collection<FieldAccess>>();
+	private static final ConcurrentMap<Class<?>, Collection<FieldAccess>> fieldsOfASTClasses = new ConcurrentHashMap<Class<?>, Collection<FieldAccess>>();
 	
 	/** Returns FieldAccess objects for the stated class. Each field that contains objects of the kind returned by
 	 * {@link #getStatementTypes()}, either directly or inside of an array or java.util.collection (or array-of-arrays,
-	 * or collection-of-collections, etcetera), is returned.
+	 * or collection-of-collections, et cetera), is returned.
 	 */
 	protected Collection<FieldAccess> fieldsOf(Class<?> c) {
 		Collection<FieldAccess> fields = fieldsOfASTClasses.get(c);
@@ -221,8 +228,8 @@ public abstract class AST<A extends AST<A, L, N>, L extends LombokNode<A, L, N>,
 		
 		fields = new ArrayList<FieldAccess>();
 		getFields(c, fields);
-		fieldsOfASTClasses.put(c, fields);
-		return fields;
+		fieldsOfASTClasses.putIfAbsent(c, fields);
+		return fieldsOfASTClasses.get(c);
 	}
 	
 	private void getFields(Class<?> c, Collection<FieldAccess> fields) {
@@ -261,13 +268,8 @@ public abstract class AST<A extends AST<A, L, N>, L extends LombokNode<A, L, N>,
 		return Object.class;
 	}
 	
-	/**
-	 * The supertypes which are considered AST Node children. Usually, the Statement, and the Expression,
-	 * though some platforms (such as Eclipse) group these under one common supertype. */
-	protected abstract Collection<Class<? extends N>> getStatementTypes();
-	
-	protected boolean shouldDrill(Class<?> parentType, Class<?> childType, String fieldName) {
-		for (Class<?> statementType : getStatementTypes()) {
+	private boolean shouldDrill(Class<?> parentType, Class<?> childType, String fieldName) {
+		for (Class<?> statementType : statementTypes) {
 			if (statementType.isAssignableFrom(childType)) return true;
 		}
 		
diff --git a/src/core/lombok/eclipse/EclipseAST.java b/src/core/lombok/eclipse/EclipseAST.java
index 6741b33a..dc2c9843 100644
--- a/src/core/lombok/eclipse/EclipseAST.java
+++ b/src/core/lombok/eclipse/EclipseAST.java
@@ -62,7 +62,7 @@ public class EclipseAST extends AST<EclipseAST, EclipseNode, ASTNode> {
 	 * @param ast The compilation unit, which serves as the top level node in the tree to be built.
 	 */
 	public EclipseAST(CompilationUnitDeclaration ast) {
-		super(toFileName(ast), packageDeclaration(ast), new EclipseImportList(ast));
+		super(toFileName(ast), packageDeclaration(ast), new EclipseImportList(ast), statementTypes());
 		this.compilationUnitDeclaration = ast;
 		setTop(buildCompilationUnit(ast));
 		this.completeParse = isComplete(ast);
@@ -477,9 +477,9 @@ public class EclipseAST extends AST<EclipseAST, EclipseNode, ASTNode> {
 		return putInMap(new EclipseNode(this, statement, childNodes, Kind.STATEMENT));
 	}
 	
-	/** For Eclipse, only Statement counts, as Expression is a subclass of it, even though this isn't
+	/* For Eclipse, only Statement counts, as Expression is a subclass of it, even though this isn't
 	 * entirely correct according to the JLS spec (only some expressions can be used as statements, not all of them). */
-	@Override protected Collection<Class<? extends ASTNode>> getStatementTypes() {
+	private static Collection<Class<? extends ASTNode>> statementTypes() {
 		return Collections.<Class<? extends ASTNode>>singleton(Statement.class);
 	}
 	
diff --git a/src/core/lombok/javac/JavacAST.java b/src/core/lombok/javac/JavacAST.java
index da61361d..106a29ae 100644
--- a/src/core/lombok/javac/JavacAST.java
+++ b/src/core/lombok/javac/JavacAST.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2015 The Project Lombok Authors.
+ * Copyright (C) 2009-2016 The Project Lombok Authors.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -28,6 +28,8 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 
 import javax.annotation.processing.Messager;
 import javax.tools.Diagnostic;
@@ -79,7 +81,7 @@ public class JavacAST extends AST<JavacAST, JavacNode, JCTree> {
 	 * @param top The compilation unit, which serves as the top level node in the tree to be built.
 	 */
 	public JavacAST(Messager messager, Context context, JCCompilationUnit top) {
-		super(sourceName(top), PackageName.getPackageName(top), new JavacImportList(top));
+		super(sourceName(top), PackageName.getPackageName(top), new JavacImportList(top), statementTypes());
 		setTop(buildCompilationUnit(top));
 		this.context = context;
 		this.messager = messager;
@@ -315,7 +317,6 @@ public class JavacAST extends AST<JavacAST, JavacNode, JCTree> {
 			// @Foo int x, y; is handled in javac by putting the same annotation node on 2 JCVariableDecls.
 			return null;
 		}
-		
 		return putInMap(new JavacNode(this, annotation, null, Kind.ANNOTATION));
 	}
 	
@@ -333,12 +334,40 @@ public class JavacAST extends AST<JavacAST, JavacNode, JCTree> {
 		if (statement instanceof JCClassDecl) return buildType((JCClassDecl)statement);
 		if (statement instanceof JCVariableDecl) return buildLocalVar((JCVariableDecl)statement, Kind.LOCAL);
 		if (statement instanceof JCTry) return buildTry((JCTry) statement);
-		
+		if (statement.getClass().getSimpleName().equals("JCLambda")) return buildLambda(statement);
 		if (setAndGetAsHandled(statement)) return null;
 		
 		return drill(statement);
 	}
 	
+	private JavacNode buildLambda(JCTree jcTree) {
+		return buildStatementOrExpression(getBody(jcTree));
+	}
+	
+	private JCTree getBody(JCTree jcTree) {
+		try {
+			return (JCTree) getBodyMethod(jcTree.getClass()).invoke(jcTree);
+		} catch (Exception e) {
+			throw Javac.sneakyThrow(e);
+		}
+	}
+	
+	private final static ConcurrentMap<Class<?>, Method> getBodyMethods = new ConcurrentHashMap<Class<?>, Method>();
+	
+	private Method getBodyMethod(Class<?> c) {
+		Method m = getBodyMethods.get(c);
+		if (m != null) {
+			return m;
+		}
+		try {
+			m = c.getMethod("getBody");
+		} catch (NoSuchMethodException e) {
+			throw Javac.sneakyThrow(e);
+		}
+		getBodyMethods.putIfAbsent(c, m);
+		return getBodyMethods.get(c);
+	}
+	
 	private JavacNode drill(JCTree statement) {
 		try {
 			List<JavacNode> childNodes = new ArrayList<JavacNode>();
@@ -354,9 +383,8 @@ public class JavacAST extends AST<JavacAST, JavacNode, JCTree> {
 		}
 	}
 	
-	/** For javac, both JCExpression and JCStatement are considered as valid children types. */
-	@Override
-	protected Collection<Class<? extends JCTree>> getStatementTypes() {
+	/* For javac, both JCExpression and JCStatement are considered as valid children types. */
+	private static Collection<Class<? extends JCTree>> statementTypes() {
 		Collection<Class<? extends JCTree>> collection = new ArrayList<Class<? extends JCTree>>(3);
 		collection.add(JCStatement.class);
 		collection.add(JCExpression.class);