Massive change to the eclipse handlers: They now set the 'generatedBy' flag which we can use to patch eclipse in specific places to ignore generated nodes.

9 files changed, 477 insertions, 198 deletions

diff --git a/src/lombok/eclipse/handlers/HandleCleanup.java b/src/lombok/eclipse/handlers/HandleCleanup.java
index 9621e81c..07c921ab 100644
--- a/src/lombok/eclipse/handlers/HandleCleanup.java
+++ b/src/lombok/eclipse/handlers/HandleCleanup.java
@@ -26,6 +26,7 @@ import java.util.Arrays;
 import lombok.Cleanup;
 import lombok.core.AnnotationValues;
 import lombok.core.AST.Kind;
+import lombok.eclipse.Eclipse;
 import lombok.eclipse.EclipseAnnotationHandler;
 import lombok.eclipse.EclipseAST.Node;
 
@@ -134,15 +135,18 @@ public class HandleCleanup implements EclipseAnnotationHandler<Cleanup> {
 		doAssignmentCheck(annotationNode, tryBlock, decl.name);
 		
 		TryStatement tryStatement = new TryStatement();
+		Eclipse.setGeneratedBy(tryStatement, ast);
 		tryStatement.tryBlock = new Block(0);
 		tryStatement.tryBlock.statements = tryBlock;
 		newStatements[start] = tryStatement;
 		
 		Statement[] finallyBlock = new Statement[1];
 		MessageSend unsafeClose = new MessageSend();
+		Eclipse.setGeneratedBy(unsafeClose, ast);
 		unsafeClose.sourceStart = ast.sourceStart;
 		unsafeClose.sourceEnd = ast.sourceEnd;
 		SingleNameReference receiver = new SingleNameReference(decl.name, 0);
+		Eclipse.setGeneratedBy(receiver, ast);
 		unsafeClose.receiver = receiver;
 		long nameSourcePosition = (long)ast.sourceStart << 32 | ast.sourceEnd;
 		if ( ast.memberValuePairs() != null ) for ( MemberValuePair pair : ast.memberValuePairs() ) {
@@ -155,6 +159,7 @@ public class HandleCleanup implements EclipseAnnotationHandler<Cleanup> {
 		unsafeClose.selector = cleanupName.toCharArray();
 		finallyBlock[0] = unsafeClose;
 		tryStatement.finallyBlock = new Block(0);
+		Eclipse.setGeneratedBy(tryStatement.finallyBlock, ast);
 		tryStatement.finallyBlock.statements = finallyBlock;
 		
 		tryStatement.catchArguments = null;
@@ -170,7 +175,6 @@ public class HandleCleanup implements EclipseAnnotationHandler<Cleanup> {
 		
 		ancestor.rebuild();
 		
-		
 		return true;
 	}
 	
diff --git a/src/lombok/eclipse/handlers/HandleData.java b/src/lombok/eclipse/handlers/HandleData.java
index 385f56d4..2761c20b 100644
--- a/src/lombok/eclipse/handlers/HandleData.java
+++ b/src/lombok/eclipse/handlers/HandleData.java
@@ -122,21 +122,23 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
 		return false;
 	}
 	
-	private ConstructorDeclaration createConstructor(boolean isPublic, Node type, Collection<Node> fields, ASTNode pos) {
-		long p = (long)pos.sourceStart << 32 | pos.sourceEnd;
+	private ConstructorDeclaration createConstructor(boolean isPublic, Node type, Collection<Node> fields, ASTNode source) {
+		long p = (long)source.sourceStart << 32 | source.sourceEnd;
 		
 		ConstructorDeclaration constructor = new ConstructorDeclaration(
 				((CompilationUnitDeclaration) type.top().get()).compilationResult);
+		Eclipse.setGeneratedBy(constructor, source);
 		
 		constructor.modifiers = PKG.toModifier(isPublic ? AccessLevel.PUBLIC : AccessLevel.PRIVATE);
 		constructor.annotations = null;
 		constructor.selector = ((TypeDeclaration)type.get()).name;
 		constructor.constructorCall = new ExplicitConstructorCall(ExplicitConstructorCall.ImplicitSuper);
+		Eclipse.setGeneratedBy(constructor.constructorCall, source);
 		constructor.thrownExceptions = null;
 		constructor.typeParameters = null;
 		constructor.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
-		constructor.bodyStart = constructor.declarationSourceStart = constructor.sourceStart = pos.sourceStart;
-		constructor.bodyEnd = constructor.declarationSourceEnd = constructor.sourceEnd = pos.sourceEnd;
+		constructor.bodyStart = constructor.declarationSourceStart = constructor.sourceStart = source.sourceStart;
+		constructor.bodyEnd = constructor.declarationSourceEnd = constructor.sourceEnd = source.sourceEnd;
 		constructor.arguments = null;
 		
 		List<Argument> args = new ArrayList<Argument>();
@@ -146,19 +148,26 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
 		for ( Node fieldNode : fields ) {
 			FieldDeclaration field = (FieldDeclaration) fieldNode.get();
 			FieldReference thisX = new FieldReference(("this." + new String(field.name)).toCharArray(), p);
+			Eclipse.setGeneratedBy(thisX, source);
 			thisX.receiver = new ThisReference((int)(p >> 32), (int)p);
+			Eclipse.setGeneratedBy(thisX.receiver, source);
 			thisX.token = field.name;
 			
-			assigns.add(new Assignment(thisX, new SingleNameReference(field.name, p), (int)p));
+			SingleNameReference assignmentNameRef = new SingleNameReference(field.name, p);
+			Eclipse.setGeneratedBy(assignmentNameRef, source);
+			Assignment assignment = new Assignment(thisX, assignmentNameRef, (int)p);
+			Eclipse.setGeneratedBy(assignment, source);
+			assigns.add(assignment);
 			long fieldPos = (((long)field.sourceStart) << 32) | field.sourceEnd;
-			Argument argument = new Argument(field.name, fieldPos, copyType(field.type), Modifier.FINAL);
+			Argument argument = new Argument(field.name, fieldPos, copyType(field.type, source), Modifier.FINAL);
+			Eclipse.setGeneratedBy(argument, source);
 			Annotation[] nonNulls = findAnnotations(field, TransformationsUtil.NON_NULL_PATTERN);
 			Annotation[] nullables = findAnnotations(field, TransformationsUtil.NULLABLE_PATTERN);
 			if (nonNulls.length != 0) {
-				Statement nullCheck = generateNullCheck(field);
+				Statement nullCheck = generateNullCheck(field, source);
 				if (nullCheck != null) nullChecks.add(nullCheck);
 			}
-			Annotation[] copiedAnnotations = copyAnnotations(nonNulls, nullables, p);
+			Annotation[] copiedAnnotations = copyAnnotations(nonNulls, nullables, source);
 			if (copiedAnnotations.length != 0) argument.annotations = copiedAnnotations;
 			args.add(argument);
 		}
@@ -169,11 +178,13 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
 		return constructor;
 	}
 	
-	private MethodDeclaration createStaticConstructor(String name, Node type, Collection<Node> fields, ASTNode pos) {
-		long p = (long)pos.sourceStart << 32 | pos.sourceEnd;
+	private MethodDeclaration createStaticConstructor(String name, Node type, Collection<Node> fields, ASTNode source) {
+		int pS = source.sourceStart, pE = source.sourceEnd;
+		long p = (long)pS << 32 | pE;
 		
 		MethodDeclaration constructor = new MethodDeclaration(
 				((CompilationUnitDeclaration) type.top().get()).compilationResult);
+		Eclipse.setGeneratedBy(constructor, source);
 		
 		constructor.modifiers = PKG.toModifier(AccessLevel.PUBLIC) | Modifier.STATIC;
 		TypeDeclaration typeDecl = (TypeDeclaration) type.get();
@@ -181,38 +192,49 @@ public class HandleData implements EclipseAnnotationHandler<Data> {
 			TypeReference[] refs = new TypeReference[typeDecl.typeParameters.length];
 			int idx = 0;
 			for ( TypeParameter param : typeDecl.typeParameters ) {
-				refs[idx++] = new SingleTypeReference(param.name, (long)param.sourceStart << 32 | param.sourceEnd);
+				TypeReference typeRef = new SingleTypeReference(param.name, (long)param.sourceStart << 32 | param.sourceEnd);
+				Eclipse.setGeneratedBy(typeRef, source);
+				refs[idx++] = typeRef;
 			}
 			constructor.returnType = new ParameterizedSingleTypeReference(typeDecl.name, refs, 0, p);
 		} else constructor.returnType = new SingleTypeReference(((TypeDeclaration)type.get()).name, p);
+		Eclipse.setGeneratedBy(constructor.returnType, source);
 		constructor.annotations = null;
 		constructor.selector = name.toCharArray();
 		constructor.thrownExceptions = null;
-		constructor.typeParameters = copyTypeParams(((TypeDeclaration)type.get()).typeParameters);
+		constructor.typeParameters = copyTypeParams(((TypeDeclaration)type.get()).typeParameters, source);
 		constructor.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
-		constructor.bodyStart = constructor.declarationSourceStart = constructor.sourceStart = pos.sourceStart;
-		constructor.bodyEnd = constructor.declarationSourceEnd = constructor.sourceEnd = pos.sourceEnd;
+		constructor.bodyStart = constructor.declarationSourceStart = constructor.sourceStart = source.sourceStart;
+		constructor.bodyEnd = constructor.declarationSourceEnd = constructor.sourceEnd = source.sourceEnd;
 		
 		List<Argument> args = new ArrayList<Argument>();
 		List<Expression> assigns = new ArrayList<Expression>();
 		AllocationExpression statement = new AllocationExpression();
-		statement.type = copyType(constructor.returnType);
+		statement.sourceStart = pS; statement.sourceEnd = pE;
+		Eclipse.setGeneratedBy(statement, source);
+		statement.type = copyType(constructor.returnType, source);
 		
 		for ( Node fieldNode : fields ) {
 			FieldDeclaration field = (FieldDeclaration) fieldNode.get();
 			long fieldPos = (((long)field.sourceStart) << 32) | field.sourceEnd;
-			assigns.add(new SingleNameReference(field.name, fieldPos));
+			SingleNameReference nameRef = new SingleNameReference(field.name, fieldPos);
+			Eclipse.setGeneratedBy(nameRef, source);
+			assigns.add(nameRef);
 			
-			Argument argument = new Argument(field.name, fieldPos, copyType(field.type), 0);
+			Argument argument = new Argument(field.name, fieldPos, copyType(field.type, source), 0);
+			Eclipse.setGeneratedBy(argument, source);
+
 			Annotation[] copiedAnnotations = copyAnnotations(
-					findAnnotations(field, TransformationsUtil.NON_NULL_PATTERN), findAnnotations(field, TransformationsUtil.NULLABLE_PATTERN), p);
+					findAnnotations(field, TransformationsUtil.NON_NULL_PATTERN),
+					findAnnotations(field, TransformationsUtil.NULLABLE_PATTERN), source);
 			if (copiedAnnotations.length != 0) argument.annotations = copiedAnnotations;
-			args.add(new Argument(field.name, fieldPos, copyType(field.type), Modifier.FINAL));
+			args.add(new Argument(field.name, fieldPos, copyType(field.type, source), Modifier.FINAL));
 		}
 		
 		statement.arguments = assigns.isEmpty() ? null : assigns.toArray(new Expression[assigns.size()]);
 		constructor.arguments = args.isEmpty() ? null : args.toArray(new Argument[args.size()]);
 		constructor.statements = new Statement[] { new ReturnStatement(statement, (int)(p >> 32), (int)p) };
+		Eclipse.setGeneratedBy(constructor.statements[0], source);
 		return constructor;
 	}
 }
diff --git a/src/lombok/eclipse/handlers/HandleEqualsAndHashCode.java b/src/lombok/eclipse/handlers/HandleEqualsAndHashCode.java
index 46792236..209c095c 100644
--- a/src/lombok/eclipse/handlers/HandleEqualsAndHashCode.java
+++ b/src/lombok/eclipse/handlers/HandleEqualsAndHashCode.java
@@ -234,22 +234,24 @@ public class HandleEqualsAndHashCode implements EclipseAnnotationHandler<EqualsA
 		return true;
 	}
 	
-	private MethodDeclaration createHashCode(Node type, Collection<Node> fields, boolean callSuper, ASTNode pos) {
-		int pS = pos.sourceStart, pE = pos.sourceEnd;
+	private MethodDeclaration createHashCode(Node type, Collection<Node> fields, boolean callSuper, ASTNode source) {
+		int pS = source.sourceStart, pE = source.sourceEnd;
 		long p = (long)pS << 32 | pE;
 		
 		MethodDeclaration method = new MethodDeclaration(
 				((CompilationUnitDeclaration) type.top().get()).compilationResult);
+		Eclipse.setGeneratedBy(method, source);
 		
 		method.modifiers = PKG.toModifier(AccessLevel.PUBLIC);
 		method.returnType = TypeReference.baseTypeReference(TypeIds.T_int, 0);
-		method.annotations = new Annotation[] {makeMarkerAnnotation(TypeConstants.JAVA_LANG_OVERRIDE, p)};
+		Eclipse.setGeneratedBy(method.returnType, source);
+		method.annotations = new Annotation[] {makeMarkerAnnotation(TypeConstants.JAVA_LANG_OVERRIDE, source)};
 		method.selector = "hashCode".toCharArray();
 		method.thrownExceptions = null;
 		method.typeParameters = null;
 		method.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
-		method.bodyStart = method.declarationSourceStart = method.sourceStart = pos.sourceStart;
-		method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = pos.sourceEnd;
+		method.bodyStart = method.declarationSourceStart = method.sourceStart = source.sourceStart;
+		method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = source.sourceEnd;
 		method.arguments = null;
 		
 		List<Statement> statements = new ArrayList<Statement>();
@@ -263,23 +265,34 @@ public class HandleEqualsAndHashCode implements EclipseAnnotationHandler<EqualsA
 			/* Without fields, PRIME isn't used, and that would trigger a 'local variable not used' warning. */
 			if ( !isEmpty || callSuper ) {
 				LocalDeclaration primeDecl = new LocalDeclaration(PRIME, pS, pE);
+				Eclipse.setGeneratedBy(primeDecl, source);
 				primeDecl.modifiers |= Modifier.FINAL;
 				primeDecl.type = TypeReference.baseTypeReference(TypeIds.T_int, 0);
+				primeDecl.type.sourceStart = pS; primeDecl.type.sourceEnd = pE;
+				Eclipse.setGeneratedBy(primeDecl.type, source);
 				primeDecl.initialization = new IntLiteral("31".toCharArray(), pS, pE);
+				Eclipse.setGeneratedBy(primeDecl.initialization, source);
 				statements.add(primeDecl);
 			}
 		}
 		
 		/* int result = 1; */ {
 			LocalDeclaration resultDecl = new LocalDeclaration(RESULT, pS, pE);
+			Eclipse.setGeneratedBy(resultDecl, source);
 			resultDecl.initialization = new IntLiteral("1".toCharArray(), pS, pE);
+			Eclipse.setGeneratedBy(resultDecl.initialization, source);
 			resultDecl.type = TypeReference.baseTypeReference(TypeIds.T_int, 0);
+			resultDecl.type.sourceStart = pS; resultDecl.type.sourceEnd = pE;
+			Eclipse.setGeneratedBy(resultDecl.type, source);
 			statements.add(resultDecl);
 		}
 		
 		if ( callSuper ) {
 			MessageSend callToSuper = new MessageSend();
+			Eclipse.setGeneratedBy(callToSuper, source);
+			callToSuper.sourceStart = pS; callToSuper.sourceEnd = pE;
 			callToSuper.receiver = new SuperReference(pS, pE);
+			Eclipse.setGeneratedBy(callToSuper.receiver, source);
 			callToSuper.selector = "hashCode".toCharArray();
 			intoResult.add(callToSuper);
 		}
@@ -292,59 +305,79 @@ public class HandleEqualsAndHashCode implements EclipseAnnotationHandler<EqualsA
 				if ( Arrays.equals(TypeConstants.FLOAT, token) ) {
 					/* Float.floatToIntBits(fieldName) */
 					MessageSend floatToIntBits = new MessageSend();
-					floatToIntBits.receiver = generateQualifiedNameRef(p, TypeConstants.JAVA_LANG_FLOAT);
+					floatToIntBits.sourceStart = pS; floatToIntBits.sourceEnd = pE;
+					Eclipse.setGeneratedBy(floatToIntBits, source);
+					floatToIntBits.receiver = generateQualifiedNameRef(source, TypeConstants.JAVA_LANG_FLOAT);
 					floatToIntBits.selector = "floatToIntBits".toCharArray();
-					floatToIntBits.arguments = new Expression[] { generateFieldReference(f.name, p) };
+					floatToIntBits.arguments = new Expression[] { generateFieldReference(f.name, source) };
 					intoResult.add(floatToIntBits);
 				} else if ( Arrays.equals(TypeConstants.DOUBLE, token) ) {
 					/* longToIntForHashCode(Double.doubleToLongBits(fieldName)) */
 					MessageSend doubleToLongBits = new MessageSend();
-					doubleToLongBits.receiver = generateQualifiedNameRef(p, TypeConstants.JAVA_LANG_DOUBLE);
+					doubleToLongBits.sourceStart = pS; doubleToLongBits.sourceEnd = pE;
+					Eclipse.setGeneratedBy(doubleToLongBits, source);
+					doubleToLongBits.receiver = generateQualifiedNameRef(source, TypeConstants.JAVA_LANG_DOUBLE);
 					doubleToLongBits.selector = "doubleToLongBits".toCharArray();
-					doubleToLongBits.arguments = new Expression[] { generateFieldReference(f.name, p) };
+					doubleToLongBits.arguments = new Expression[] { generateFieldReference(f.name, source) };
 					final char[] tempName = ("temp" + ++tempCounter).toCharArray();
 					LocalDeclaration tempVar = new LocalDeclaration(tempName, pS, pE);
+					Eclipse.setGeneratedBy(tempVar, source);
 					tempVar.initialization = doubleToLongBits;
 					tempVar.type = TypeReference.baseTypeReference(TypeIds.T_long, 0);
+					tempVar.type.sourceStart = pS; tempVar.type.sourceEnd = pE;
+					Eclipse.setGeneratedBy(tempVar.type, source);
 					tempVar.modifiers = Modifier.FINAL;
 					statements.add(tempVar);
-					intoResult.add(longToIntForHashCode(
-							new SingleNameReference(tempName, p), new SingleNameReference(tempName, p), p));
+					SingleNameReference copy1 = new SingleNameReference(tempName, p);
+					Eclipse.setGeneratedBy(copy1, source);
+					SingleNameReference copy2 = new SingleNameReference(tempName, p);
+					Eclipse.setGeneratedBy(copy2, source);
+					intoResult.add(longToIntForHashCode(copy1, copy2, source));
 				} else if ( Arrays.equals(TypeConstants.BOOLEAN, token) ) {
 					/* booleanField ? 1231 : 1237 */
-					intoResult.add(new ConditionalExpression(
-							generateFieldReference(f.name, p),
-							new IntLiteral("1231".toCharArray(), pS, pE),
-							new IntLiteral("1237".toCharArray(), pS, pE)));
+					IntLiteral int1231 = new IntLiteral("1231".toCharArray(), pS, pE);
+					Eclipse.setGeneratedBy(int1231, source);
+					IntLiteral int1237 = new IntLiteral("1237".toCharArray(), pS, pE);
+					Eclipse.setGeneratedBy(int1237, source);
+					ConditionalExpression int1231or1237 = new ConditionalExpression(
+							generateFieldReference(f.name, source), int1231, int1237);
+					Eclipse.setGeneratedBy(int1231or1237, source);
+					intoResult.add(int1231or1237);
 				} else if ( Arrays.equals(TypeConstants.LONG, token) ) {
-					intoResult.add(longToIntForHashCode(generateFieldReference(f.name, p), generateFieldReference(f.name, p), p));
+					intoResult.add(longToIntForHashCode(generateFieldReference(f.name, source), generateFieldReference(f.name, source), source));
 				} else if ( BUILT_IN_TYPES.contains(new String(token)) ) {
-					intoResult.add(generateFieldReference(f.name, p));
+					intoResult.add(generateFieldReference(f.name, source));
 				} else /* objects */ {
 					/* this.fieldName == null ? 0 : this.fieldName.hashCode() */
 					MessageSend hashCodeCall = new MessageSend();
-					hashCodeCall.receiver = generateFieldReference(f.name, p);
+					hashCodeCall.sourceStart = pS; hashCodeCall.sourceEnd = pE;
+					Eclipse.setGeneratedBy(hashCodeCall, source);
+					hashCodeCall.receiver = generateFieldReference(f.name, source);
 					hashCodeCall.selector = "hashCode".toCharArray();
+					NullLiteral nullLiteral = new NullLiteral(pS, pE);
+					Eclipse.setGeneratedBy(nullLiteral, source);
 					EqualExpression objIsNull = new EqualExpression(
-							generateFieldReference(f.name, p),
-							new NullLiteral(pS, pE),
-							OperatorIds.EQUAL_EQUAL);
-					ConditionalExpression nullOrHashCode = new ConditionalExpression(
-							objIsNull,
-							new IntLiteral("0".toCharArray(), pS, pE),
-							hashCodeCall);
+							generateFieldReference(f.name, source), nullLiteral, OperatorIds.EQUAL_EQUAL);
+					Eclipse.setGeneratedBy(objIsNull, source);
+					IntLiteral int0 = new IntLiteral("0".toCharArray(), pS, pE);
+					Eclipse.setGeneratedBy(int0, source);
+					ConditionalExpression nullOrHashCode = new ConditionalExpression(objIsNull, int0, hashCodeCall);
+					nullOrHashCode.sourceStart = pS; nullOrHashCode.sourceEnd = pE;
+					Eclipse.setGeneratedBy(nullOrHashCode, source);
 					intoResult.add(nullOrHashCode);
 				}
 			} else if ( f.type.dimensions() > 0 && token != null ) {
 				/* Arrays.deepHashCode(array)  //just hashCode for simple arrays */
 				MessageSend arraysHashCodeCall = new MessageSend();
-				arraysHashCodeCall.receiver = generateQualifiedNameRef(p, TypeConstants.JAVA, TypeConstants.UTIL, "Arrays".toCharArray());
+				arraysHashCodeCall.sourceStart = pS; arraysHashCodeCall.sourceEnd = pE;
+				Eclipse.setGeneratedBy(arraysHashCodeCall, source);
+				arraysHashCodeCall.receiver = generateQualifiedNameRef(source, TypeConstants.JAVA, TypeConstants.UTIL, "Arrays".toCharArray());
 				if ( f.type.dimensions() > 1 || !BUILT_IN_TYPES.contains(new String(token)) ) {
 					arraysHashCodeCall.selector = "deepHashCode".toCharArray();
 				} else {
 					arraysHashCodeCall.selector = "hashCode".toCharArray();
 				}
-				arraysHashCodeCall.arguments = new Expression[] { generateFieldReference(f.name, p) };
+				arraysHashCodeCall.arguments = new Expression[] { generateFieldReference(f.name, source) };
 				intoResult.add(arraysHashCodeCall);
 			}
 		}
@@ -352,73 +385,117 @@ public class HandleEqualsAndHashCode implements EclipseAnnotationHandler<EqualsA
 		/* fold each intoResult entry into:
 		   result = result * PRIME + (item); */ {
 			for ( Expression ex : intoResult ) {
-				BinaryExpression multiplyByPrime = new BinaryExpression(new SingleNameReference(RESULT, p),
-						new SingleNameReference(PRIME, 0), OperatorIds.MULTIPLY);
+				SingleNameReference resultRef = new SingleNameReference(RESULT, p);
+				Eclipse.setGeneratedBy(resultRef, source);
+				SingleNameReference primeRef = new SingleNameReference(PRIME, p);
+				Eclipse.setGeneratedBy(primeRef, source);
+				BinaryExpression multiplyByPrime = new BinaryExpression(resultRef, primeRef, OperatorIds.MULTIPLY);
+				multiplyByPrime.sourceStart = pS; multiplyByPrime.sourceEnd = pE;
+				Eclipse.setGeneratedBy(multiplyByPrime, source);
 				BinaryExpression addItem = new BinaryExpression(multiplyByPrime, ex, OperatorIds.PLUS);
-				statements.add(new Assignment(new SingleNameReference(RESULT, p), addItem, pE));
+				addItem.sourceStart = pS; addItem.sourceEnd = pE;
+				Eclipse.setGeneratedBy(addItem, source);
+				resultRef = new SingleNameReference(RESULT, p);
+				Eclipse.setGeneratedBy(resultRef, source);
+				Assignment assignment = new Assignment(resultRef, addItem, pE);
+				assignment.sourceStart = pS; assignment.sourceEnd = pE;
+				Eclipse.setGeneratedBy(assignment, source);
+				statements.add(assignment);
 			}
 		}
 		
 		/* return result; */ {
-			statements.add(new ReturnStatement(new SingleNameReference(RESULT, p), pS, pE));
+			SingleNameReference resultRef = new SingleNameReference(RESULT, p);
+			Eclipse.setGeneratedBy(resultRef, source);
+			ReturnStatement returnStatement = new ReturnStatement(resultRef, pS, pE);
+			Eclipse.setGeneratedBy(returnStatement, source);
+			statements.add(returnStatement);
 		}
 		method.statements = statements.toArray(new Statement[statements.size()]);
 		return method;
 	}
 	
-	private MethodDeclaration createEquals(Node type, Collection<Node> fields, boolean callSuper, ASTNode pos) {
-		int pS = pos.sourceStart; int pE = pos.sourceEnd;
+	private MethodDeclaration createEquals(Node type, Collection<Node> fields, boolean callSuper, ASTNode source) {
+		int pS = source.sourceStart; int pE = source.sourceEnd;
 		long p = (long)pS << 32 | pE;
 		
 		MethodDeclaration method = new MethodDeclaration(
 				((CompilationUnitDeclaration) type.top().get()).compilationResult);
-		
+		Eclipse.setGeneratedBy(method, source);
 		method.modifiers = PKG.toModifier(AccessLevel.PUBLIC);
 		method.returnType = TypeReference.baseTypeReference(TypeIds.T_boolean, 0);
-		method.annotations = new Annotation[] {makeMarkerAnnotation(TypeConstants.JAVA_LANG_OVERRIDE, p)};
+		method.returnType.sourceStart = pS; method.returnType.sourceEnd = pE;
+		Eclipse.setGeneratedBy(method.returnType, source);
+		method.annotations = new Annotation[] {makeMarkerAnnotation(TypeConstants.JAVA_LANG_OVERRIDE, source)};
 		method.selector = "equals".toCharArray();
 		method.thrownExceptions = null;
 		method.typeParameters = null;
 		method.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
-		method.bodyStart = method.declarationSourceStart = method.sourceStart = pos.sourceStart;
-		method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = pos.sourceEnd;
-		method.arguments = new Argument[] {
-				new Argument(new char[] { 'o' }, 0,
-						new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, new long[] { p, p, p }), Modifier.FINAL)
-		};
+		method.bodyStart = method.declarationSourceStart = method.sourceStart = source.sourceStart;
+		method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = source.sourceEnd;
+		TypeReference objectRef = new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, new long[] { p, p, p });
+		Eclipse.setGeneratedBy(objectRef, source);
+		method.arguments = new Argument[] {new Argument(new char[] { 'o' }, 0, objectRef, Modifier.FINAL)};
+		method.arguments[0].sourceStart = pS; method.arguments[0].sourceEnd = pE;
+		Eclipse.setGeneratedBy(method.arguments[0], source);
 		
 		List<Statement> statements = new ArrayList<Statement>();
 		
 		/* if ( o == this ) return true; */ {
-			EqualExpression otherEqualsThis = new EqualExpression(
-					new SingleNameReference(new char[] { 'o' }, p),
-					new ThisReference(pS, pE), OperatorIds.EQUAL_EQUAL);
+			SingleNameReference oRef = new SingleNameReference(new char[] { 'o' }, p);
+			Eclipse.setGeneratedBy(oRef, source);
+			ThisReference thisRef = new ThisReference(pS, pE);
+			Eclipse.setGeneratedBy(thisRef, source);
+			EqualExpression otherEqualsThis = new EqualExpression(oRef, thisRef, OperatorIds.EQUAL_EQUAL);
+			Eclipse.setGeneratedBy(otherEqualsThis, source);
 			
-			ReturnStatement returnTrue = new ReturnStatement(new TrueLiteral(pS, pE), pS, pE);
+			TrueLiteral trueLiteral = new TrueLiteral(pS, pE);
+			Eclipse.setGeneratedBy(trueLiteral, source);
+			ReturnStatement returnTrue = new ReturnStatement(trueLiteral, pS, pE);
+			Eclipse.setGeneratedBy(returnTrue, source);
 			IfStatement ifOtherEqualsThis = new IfStatement(otherEqualsThis, returnTrue, pS, pE);
+			Eclipse.setGeneratedBy(ifOtherEqualsThis, source);
 			statements.add(ifOtherEqualsThis);
 		}
 		
 		/* if ( o == null ) return false; */ {
-			EqualExpression otherEqualsNull = new EqualExpression(
-					new SingleNameReference(new char[] { 'o' }, p),
-					new NullLiteral(pS, pE), OperatorIds.EQUAL_EQUAL);
+			SingleNameReference oRef = new SingleNameReference(new char[] { 'o' }, p);
+			Eclipse.setGeneratedBy(oRef, source);
+			NullLiteral nullLiteral = new NullLiteral(pS, pE);
+			Eclipse.setGeneratedBy(nullLiteral, source);
+			EqualExpression otherEqualsNull = new EqualExpression(oRef, nullLiteral, OperatorIds.EQUAL_EQUAL);
+			Eclipse.setGeneratedBy(otherEqualsNull, source);
 			
-			ReturnStatement returnFalse = new ReturnStatement(new FalseLiteral(pS, pE), pS, pE);
+			FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
+			Eclipse.setGeneratedBy(falseLiteral, source);
+			ReturnStatement returnFalse = new ReturnStatement(falseLiteral, pS, pE);
+			Eclipse.setGeneratedBy(returnFalse, source);
 			IfStatement ifOtherEqualsNull = new IfStatement(otherEqualsNull, returnFalse, pS, pE);
+			Eclipse.setGeneratedBy(ifOtherEqualsNull, source);
 			statements.add(ifOtherEqualsNull);
 		}
 		
 		/* if ( o.getClass() != getClass() ) return false; */ {
 			MessageSend otherGetClass = new MessageSend();
+			otherGetClass.sourceStart = pS; otherGetClass.sourceEnd = pE;
+			Eclipse.setGeneratedBy(otherGetClass, source);
 			otherGetClass.receiver = new SingleNameReference(new char[] { 'o' }, p);
+			Eclipse.setGeneratedBy(otherGetClass.receiver, source);
 			otherGetClass.selector = "getClass".toCharArray();
 			MessageSend thisGetClass = new MessageSend();
+			thisGetClass.sourceStart = pS; thisGetClass.sourceEnd = pE;
+			Eclipse.setGeneratedBy(thisGetClass, source);
 			thisGetClass.receiver = new ThisReference(pS, pE);
+			Eclipse.setGeneratedBy(thisGetClass.receiver, source);
 			thisGetClass.selector = "getClass".toCharArray();
 			EqualExpression classesNotEqual = new EqualExpression(otherGetClass, thisGetClass, OperatorIds.NOT_EQUAL);
-			ReturnStatement returnFalse = new ReturnStatement(new FalseLiteral(pS, pE), pS, pE);
+			Eclipse.setGeneratedBy(classesNotEqual, source);
+			FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
+			Eclipse.setGeneratedBy(falseLiteral, source);
+			ReturnStatement returnFalse = new ReturnStatement(falseLiteral, pS, pE);
+			Eclipse.setGeneratedBy(returnFalse, source);
 			IfStatement ifClassesNotEqual = new IfStatement(classesNotEqual, returnFalse, pS, pE);
+			Eclipse.setGeneratedBy(ifClassesNotEqual, source);
 			statements.add(ifClassesNotEqual);
 		}
 		
@@ -427,12 +504,22 @@ public class HandleEqualsAndHashCode implements EclipseAnnotationHandler<EqualsA
 		/* if ( !super.equals(o) ) return false; */
 		if ( callSuper ) {
 			MessageSend callToSuper = new MessageSend();
+			callToSuper.sourceStart = pS; callToSuper.sourceEnd = pE;
+			Eclipse.setGeneratedBy(callToSuper, source);
 			callToSuper.receiver = new SuperReference(pS, pE);
+			Eclipse.setGeneratedBy(callToSuper.receiver, source);
 			callToSuper.selector = "equals".toCharArray();
-			callToSuper.arguments = new Expression[] {new SingleNameReference(new char[] { 'o' }, p) };
+			SingleNameReference oRef = new SingleNameReference(new char[] { 'o' }, p);
+			Eclipse.setGeneratedBy(oRef, source);
+			callToSuper.arguments = new Expression[] {oRef};
 			Expression superNotEqual = new UnaryExpression(callToSuper, OperatorIds.NOT);
-			ReturnStatement returnFalse = new ReturnStatement(new FalseLiteral(pS, pE), pS, pE);
+			Eclipse.setGeneratedBy(superNotEqual, source);
+			FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
+			Eclipse.setGeneratedBy(falseLiteral, source);
+			ReturnStatement returnFalse = new ReturnStatement(falseLiteral, pS, pE);
+			Eclipse.setGeneratedBy(returnFalse, source);
 			IfStatement ifSuperEquals = new IfStatement(superNotEqual, returnFalse, pS, pE);
+			Eclipse.setGeneratedBy(ifSuperEquals, source);
 			statements.add(ifSuperEquals);
 		}
 		
@@ -440,20 +527,30 @@ public class HandleEqualsAndHashCode implements EclipseAnnotationHandler<EqualsA
 		/* MyType<?> other = (MyType<?>) o; */ {
 			if ( !fields.isEmpty() ) {
 				LocalDeclaration other = new LocalDeclaration(otherN, pS, pE);
+				Eclipse.setGeneratedBy(other, source);
 				char[] typeName = typeDecl.name;
 				Expression targetType;
 				if ( typeDecl.typeParameters == null || typeDecl.typeParameters.length == 0 ) {
 					targetType = new SingleNameReference(((TypeDeclaration)type.get()).name, p);
+					Eclipse.setGeneratedBy(targetType, source);
 					other.type = new SingleTypeReference(typeName, p);
+					Eclipse.setGeneratedBy(other.type, source);
 				} else {
 					TypeReference[] typeArgs = new TypeReference[typeDecl.typeParameters.length];
-					for ( int i = 0 ; i < typeArgs.length ; i++ ) typeArgs[i] = new Wildcard(Wildcard.UNBOUND);
+					for ( int i = 0 ; i < typeArgs.length ; i++ ) {
+						typeArgs[i] = new Wildcard(Wildcard.UNBOUND);
+						typeArgs[i].sourceStart = pS; typeArgs[i].sourceEnd = pE;
+						Eclipse.setGeneratedBy(typeArgs[i], source);
+					}
 					targetType = new ParameterizedSingleTypeReference(typeName, typeArgs, 0, p);
-					other.type = new ParameterizedSingleTypeReference(typeName, copyTypes(typeArgs), 0, p);
+					Eclipse.setGeneratedBy(targetType, source);
+					other.type = new ParameterizedSingleTypeReference(typeName, copyTypes(typeArgs, source), 0, p);
+					Eclipse.setGeneratedBy(other.type, source);
 				}
-				other.initialization = new CastExpression(
-						new SingleNameReference(new char[] { 'o' }, p),
-						targetType);
+				NameReference oRef = new SingleNameReference(new char[] { 'o' }, p);
+				Eclipse.setGeneratedBy(oRef, source);
+				other.initialization = new CastExpression(oRef, targetType);
+				Eclipse.setGeneratedBy(other.initialization, source);
 				statements.add(other);
 			}
 		}
@@ -463,92 +560,156 @@ public class HandleEqualsAndHashCode implements EclipseAnnotationHandler<EqualsA
 			char[] token = f.type.getLastToken();
 			if ( f.type.dimensions() == 0 && token != null ) {
 				if ( Arrays.equals(TypeConstants.FLOAT, token) ) {
-					statements.add(generateCompareFloatOrDouble(otherN, "Float".toCharArray(), f.name, p));
+					statements.add(generateCompareFloatOrDouble(otherN, "Float".toCharArray(), f.name, source));
 				} else if ( Arrays.equals(TypeConstants.DOUBLE, token) ) {
-					statements.add(generateCompareFloatOrDouble(otherN, "Double".toCharArray(), f.name, p));
+					statements.add(generateCompareFloatOrDouble(otherN, "Double".toCharArray(), f.name, source));
 				} else if ( BUILT_IN_TYPES.contains(new String(token)) ) {
-					EqualExpression fieldsNotEqual = new EqualExpression(
-							new SingleNameReference(f.name, p),
-							generateQualifiedNameRef(p, otherN, f.name),
-							OperatorIds.NOT_EQUAL);
-					ReturnStatement returnStatement = new ReturnStatement(new FalseLiteral(pS, pE), pS, pE);
-					statements.add(new IfStatement(fieldsNotEqual, returnStatement, pS, pE));
+					NameReference fieldRef = new SingleNameReference(f.name, p);
+					Eclipse.setGeneratedBy(fieldRef, source);
+					EqualExpression fieldsNotEqual = new EqualExpression(fieldRef,
+							generateQualifiedNameRef(source, otherN, f.name), OperatorIds.NOT_EQUAL);
+					Eclipse.setGeneratedBy(fieldsNotEqual, source);
+					FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
+					Eclipse.setGeneratedBy(falseLiteral, source);
+					ReturnStatement returnStatement = new ReturnStatement(falseLiteral, pS, pE);
+					Eclipse.setGeneratedBy(returnStatement, source);
+					IfStatement ifStatement = new IfStatement(fieldsNotEqual, returnStatement, pS, pE);
+					Eclipse.setGeneratedBy(ifStatement, source);
+					statements.add(ifStatement);
 				} else /* objects */ {
-					EqualExpression fieldIsNull = new EqualExpression(
-							new SingleNameReference(f.name, p),
-							new NullLiteral(pS, pE), OperatorIds.EQUAL_EQUAL);
+					NameReference fieldNameRef = new SingleNameReference(f.name, p);
+					Eclipse.setGeneratedBy(fieldNameRef, source);
+					NullLiteral nullLiteral = new NullLiteral(pS, pE);
+					Eclipse.setGeneratedBy(nullLiteral, source);
+					EqualExpression fieldIsNull = new EqualExpression(fieldNameRef, nullLiteral, OperatorIds.EQUAL_EQUAL);
+					nullLiteral = new NullLiteral(pS, pE);
+					Eclipse.setGeneratedBy(nullLiteral, source);
 					EqualExpression otherFieldIsntNull = new EqualExpression(
-							generateQualifiedNameRef(p, otherN, f.name),
-							new NullLiteral(pS, pE), OperatorIds.NOT_EQUAL);
+							generateQualifiedNameRef(source, otherN, f.name),
+							nullLiteral, OperatorIds.NOT_EQUAL);
 					MessageSend equalsCall = new MessageSend();
+					equalsCall.sourceStart = pS; equalsCall.sourceEnd = pE;
+					Eclipse.setGeneratedBy(equalsCall, source);
 					equalsCall.receiver = new SingleNameReference(f.name, p);
+					Eclipse.setGeneratedBy(equalsCall.receiver, source);
 					equalsCall.selector = "equals".toCharArray();
-					equalsCall.arguments = new Expression[] { generateQualifiedNameRef(p, otherN, f.name) };
+					equalsCall.arguments = new Expression[] { generateQualifiedNameRef(source, otherN, f.name) };
 					UnaryExpression fieldsNotEqual = new UnaryExpression(equalsCall, OperatorIds.NOT);
+					fieldsNotEqual.sourceStart = pS; fieldsNotEqual.sourceEnd = pE;
+					Eclipse.setGeneratedBy(fieldsNotEqual, source);
 					ConditionalExpression fullEquals = new ConditionalExpression(fieldIsNull, otherFieldIsntNull, fieldsNotEqual);
-					ReturnStatement returnStatement = new ReturnStatement(new FalseLiteral(pS, pE), pS, pE);
-					statements.add(new IfStatement(fullEquals, returnStatement, pS, pE));
+					fullEquals.sourceStart = pS; fullEquals.sourceEnd = pE;
+					Eclipse.setGeneratedBy(fullEquals, source);
+					FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
+					Eclipse.setGeneratedBy(falseLiteral, source);
+					ReturnStatement returnStatement = new ReturnStatement(falseLiteral, pS, pE);
+					Eclipse.setGeneratedBy(returnStatement, source);
+					IfStatement ifStatement = new IfStatement(fullEquals, returnStatement, pS, pE);
+					Eclipse.setGeneratedBy(ifStatement, source);
+					statements.add(ifStatement);
 				}
 			} else if ( f.type.dimensions() > 0 && token != null ) {
 				MessageSend arraysEqualCall = new MessageSend();
-				arraysEqualCall.receiver = generateQualifiedNameRef(p, TypeConstants.JAVA, TypeConstants.UTIL, "Arrays".toCharArray());
+				arraysEqualCall.sourceStart = pS; arraysEqualCall.sourceEnd = pE;
+				Eclipse.setGeneratedBy(arraysEqualCall, source);
+				arraysEqualCall.receiver = generateQualifiedNameRef(source, TypeConstants.JAVA, TypeConstants.UTIL, "Arrays".toCharArray());
 				if ( f.type.dimensions() > 1 || !BUILT_IN_TYPES.contains(new String(token)) ) {
 					arraysEqualCall.selector = "deepEquals".toCharArray();
 				} else {
 					arraysEqualCall.selector = "equals".toCharArray();
 				}
-				arraysEqualCall.arguments = new Expression[] {
-						new SingleNameReference(f.name, p),
-						generateQualifiedNameRef(p, otherN, f.name) };
+				NameReference fieldNameRef = new SingleNameReference(f.name, p);
+				Eclipse.setGeneratedBy(fieldNameRef, source);
+				arraysEqualCall.arguments = new Expression[] { fieldNameRef, generateQualifiedNameRef(source, otherN, f.name) };
 				UnaryExpression arraysNotEqual = new UnaryExpression(arraysEqualCall, OperatorIds.NOT);
-				ReturnStatement returnStatement = new ReturnStatement(new FalseLiteral(pS, pE), pS, pE);
-				statements.add(new IfStatement(arraysNotEqual, returnStatement, pS, pE));
+				arraysNotEqual.sourceStart = pS; arraysNotEqual.sourceEnd = pE;
+				Eclipse.setGeneratedBy(arraysNotEqual, source);
+				FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
+				Eclipse.setGeneratedBy(falseLiteral, source);
+				ReturnStatement returnStatement = new ReturnStatement(falseLiteral, pS, pE);
+				Eclipse.setGeneratedBy(returnStatement, source);
+				IfStatement ifStatement = new IfStatement(arraysNotEqual, returnStatement, pS, pE);
+				Eclipse.setGeneratedBy(ifStatement, source);
+				statements.add(ifStatement);
 			}
 		}
 		
 		/* return true; */ {
-			statements.add(new ReturnStatement(new TrueLiteral(pS, pE), pS, pE));
+			TrueLiteral trueLiteral = new TrueLiteral(pS, pE);
+			Eclipse.setGeneratedBy(trueLiteral, source);
+			ReturnStatement returnStatement = new ReturnStatement(trueLiteral, pS, pE);
+			Eclipse.setGeneratedBy(returnStatement, source);
+			statements.add(returnStatement);
 		}
 		method.statements = statements.toArray(new Statement[statements.size()]);
 		return method;
 	}
 	
-	private IfStatement generateCompareFloatOrDouble(char[] otherN, char[] floatOrDouble, char[] fieldName, long p) {
-		int pS = (int)(p >> 32), pE = (int)p;
+	private IfStatement generateCompareFloatOrDouble(char[] otherN, char[] floatOrDouble, char[] fieldName, ASTNode source) {
+		int pS = source.sourceStart, pE = source.sourceEnd;
+		long p = (long)pS << 32 | pE;
 		/* if ( Float.compare(fieldName, other.fieldName) != 0 ) return false */
 		MessageSend floatCompare = new MessageSend();