Removed statics and lots of parameters, reimplemented recalcSourcePosition

1 files changed, 174 insertions, 172 deletions

diff --git a/src/core/lombok/eclipse/handlers/SetGeneratedByVisitor.java b/src/core/lombok/eclipse/handlers/SetGeneratedByVisitor.java
index 588efc1b..8d5648fa 100644
--- a/src/core/lombok/eclipse/handlers/SetGeneratedByVisitor.java
+++ b/src/core/lombok/eclipse/handlers/SetGeneratedByVisitor.java
@@ -104,6 +104,8 @@ import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;
 import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
 
 public final class SetGeneratedByVisitor extends ASTVisitor {
+	private static final long INT_TO_LONG_MASK = 0x00000000FFFFFFFFL;
+	
 	private final ASTNode source;
 	private final int newSourceStart;
 	private final int newSourceEnd;
@@ -114,61 +116,61 @@ public final class SetGeneratedByVisitor extends ASTVisitor {
 		this.newSourceEnd = this.source.sourceEnd;
 	}
 	
-	private static void applyOffset(JavadocAllocationExpression node, int newSourceStart, int newSourceEnd) {
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+	private void applyOffset(JavadocAllocationExpression node) {
+		applyOffsetExpression(node);
 		node.memberStart = newSourceStart;
 		node.tagSourceEnd = newSourceEnd;
 		node.tagSourceStart = newSourceStart;
 	}
 	
-	private static void applyOffset(JavadocMessageSend node, int newSourceStart, int newSourceEnd) {
-		applyOffsetMessageSend(node, newSourceStart, newSourceEnd);
+	private void applyOffset(JavadocMessageSend node) {
+		applyOffsetMessageSend(node);
 		node.tagSourceEnd = newSourceEnd;
 		node.tagSourceStart = newSourceStart;
 	}
 	
-	private static void applyOffset(JavadocSingleNameReference node, int newSourceStart, int newSourceEnd) {
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+	private void applyOffset(JavadocSingleNameReference node) {
+		applyOffsetExpression(node);
 		node.tagSourceEnd = newSourceEnd;
 		node.tagSourceStart = newSourceStart;
 	}
 	
-	private static void applyOffset(JavadocSingleTypeReference node, int newSourceStart, int newSourceEnd) {
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+	private void applyOffset(JavadocSingleTypeReference node) {
+		applyOffsetExpression(node);
 		node.tagSourceEnd = newSourceEnd;
 		node.tagSourceStart = newSourceStart;
 	}
 
-	private static void applyOffset(JavadocFieldReference node, int newSourceStart, int newSourceEnd) {
-		applyOffsetFieldReference(node, newSourceStart, newSourceEnd);
+	private void applyOffset(JavadocFieldReference node) {
+		applyOffsetFieldReference(node);
 		node.tagSourceEnd = newSourceEnd;
 		node.tagSourceStart = newSourceStart;
 	}
 	
-	private static void applyOffset(JavadocArrayQualifiedTypeReference node, int newSourceStart, int newSourceEnd) {
-		applyOffsetQualifiedTypeReference(node, newSourceStart, newSourceEnd);
+	private void applyOffset(JavadocArrayQualifiedTypeReference node) {
+		applyOffsetQualifiedTypeReference(node);
 		node.tagSourceEnd = newSourceEnd;
 		node.tagSourceStart = newSourceStart;
 	}
 	
-	private static void applyOffset(JavadocQualifiedTypeReference node, int newSourceStart, int newSourceEnd) {
-		applyOffsetQualifiedTypeReference(node, newSourceStart, newSourceEnd);
+	private void applyOffset(JavadocQualifiedTypeReference node) {
+		applyOffsetQualifiedTypeReference(node);
 		node.tagSourceEnd = newSourceEnd;
 		node.tagSourceStart = newSourceStart;
 	}
 	
-	private static void applyOffset(Annotation node, int newSourceStart, int newSourceEnd) {
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+	private void applyOffset(Annotation node) {
+		applyOffsetExpression(node);
 		node.declarationSourceEnd = newSourceEnd;
 	}
 
-	private static void applyOffset(ArrayTypeReference node, int newSourceStart, int newSourceEnd) {
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+	private void applyOffset(ArrayTypeReference node) {
+		applyOffsetExpression(node);
 		node.originalSourceEnd = newSourceEnd;
 	}
 	
-	private static void applyOffset(AbstractMethodDeclaration node, int newSourceStart, int newSourceEnd) {
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+	private void applyOffset(AbstractMethodDeclaration node) {
+		applyOffsetASTNode(node);
 		node.bodyEnd = newSourceEnd;
 		node.bodyStart = newSourceStart;
 		node.declarationSourceEnd = newSourceEnd;
@@ -176,22 +178,22 @@ public final class SetGeneratedByVisitor extends ASTVisitor {
 		node.modifiersSourceStart = newSourceStart;
 	}
 	
-	private static void applyOffset(Javadoc node, int newSourceStart, int newSourceEnd) {
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+	private void applyOffset(Javadoc node) {
+		applyOffsetASTNode(node);
 		node.valuePositions = newSourceStart;
 		for (int i = 0; i < node.inheritedPositions.length; i++) {
-			node.inheritedPositions[i] = recalcSourcePosition(node.inheritedPositions[i], newSourceStart, newSourceEnd);
+			node.inheritedPositions[i] = recalcSourcePosition(node.inheritedPositions[i]);
 		}
 	}
 
-	private static void applyOffset(Initializer node, int newSourceStart, int newSourceEnd) {
-		applyOffsetFieldDeclaration(node, newSourceStart, newSourceEnd);
+	private void applyOffset(Initializer node) {
+		applyOffsetFieldDeclaration(node);
 		node.bodyStart = newSourceStart;
 		node.bodyEnd = newSourceEnd;
 	}
 
-	private static void applyOffset(TypeDeclaration node, int newSourceStart, int newSourceEnd) {
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+	private void applyOffset(TypeDeclaration node) {
+		applyOffsetASTNode(node);
 		node.bodyEnd = newSourceEnd;
 		node.bodyStart = newSourceStart;
 		node.declarationSourceEnd = newSourceEnd;
@@ -199,703 +201,703 @@ public final class SetGeneratedByVisitor extends ASTVisitor {
 		node.modifiersSourceStart = newSourceStart;
 	}
 	
-	private static void applyOffset(ImportReference node, int newSourceStart, int newSourceEnd) {
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+	private void applyOffset(ImportReference node) {
+		applyOffsetASTNode(node);
 		node.declarationEnd = newSourceEnd;
 		node.declarationSourceEnd = newSourceEnd;
 		node.declarationSourceStart = newSourceStart;
 		for (int i = 0; i < node.sourcePositions.length; i++) {
-			node.sourcePositions[i] = recalcSourcePosition(node.sourcePositions[i], newSourceStart, newSourceEnd);
+			node.sourcePositions[i] = recalcSourcePosition(node.sourcePositions[i]);
 		}		
 	}
 
-	private static void applyOffsetASTNode(ASTNode node, int newSourceStart, int newSourceEnd) {
+	private void applyOffsetASTNode(ASTNode node) {
 		node.sourceEnd = newSourceEnd;
 		node.sourceStart = newSourceStart;
 	}
 
-	private static void applyOffsetExpression(Expression node, int newSourceStart, int newSourceEnd) {
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+	private void applyOffsetExpression(Expression node) {
+		applyOffsetASTNode(node);
 //		if (node.statementEnd != -1) {
 			node.statementEnd = newSourceEnd;
 //		}
 	}
 
-	private static void applyOffsetVariable(AbstractVariableDeclaration node, int newSourceStart, int newSourceEnd) {
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+	private void applyOffsetVariable(AbstractVariableDeclaration node) {
+		applyOffsetASTNode(node);
 		node.declarationEnd = newSourceEnd;
 		node.declarationSourceEnd = newSourceEnd;
 		node.declarationSourceStart = newSourceStart;
 		node.modifiersSourceStart = newSourceStart;
 	}
 		
-	private static void applyOffsetFieldDeclaration(FieldDeclaration node, int newSourceStart, int newSourceEnd) {
-		applyOffsetVariable(node, newSourceStart, newSourceEnd);
+	private void applyOffsetFieldDeclaration(FieldDeclaration node) {
+		applyOffsetVariable(node);
 		node.endPart1Position = newSourceEnd;
 		node.endPart2Position = newSourceEnd;
 	}
 
-	private static void applyOffsetFieldReference(FieldReference node, int newSourceStart, int newSourceEnd) {
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
-		node.nameSourcePosition = recalcSourcePosition(node.nameSourcePosition, newSourceStart, newSourceEnd);
+	private void applyOffsetFieldReference(FieldReference node) {
+		applyOffsetExpression(node);
+		node.nameSourcePosition = recalcSourcePosition(node.nameSourcePosition);
 	}
 	
-	private static void applyOffsetMessageSend(MessageSend node, int newSourceStart, int newSourceEnd) {
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
-		node.nameSourcePosition = recalcSourcePosition(node.nameSourcePosition, newSourceStart, newSourceEnd);
+	private void applyOffsetMessageSend(MessageSend node) {
+		applyOffsetExpression(node);
+		node.nameSourcePosition = recalcSourcePosition(node.nameSourcePosition);
 	}
 	
-	private static void applyOffsetQualifiedTypeReference(QualifiedTypeReference node, int newSourceStart, int newSourceEnd) {
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+	private void applyOffsetQualifiedTypeReference(QualifiedTypeReference node) {
+		applyOffsetExpression(node);
 		for (int i = 0; i < node.sourcePositions.length; i++) {
-			node.sourcePositions[i] = recalcSourcePosition(node.sourcePositions[i], newSourceStart, newSourceEnd);
+			node.sourcePositions[i] = recalcSourcePosition(node.sourcePositions[i]);
 		}
 	}
 
-	/** See {@link FieldReference#nameSourcePosition} for explanation 
-	 * @param newSourceEnd TODO*/ 
-	private static long recalcSourcePosition(long sourcePosition, int newSourceStart, int newSourceEnd) {
-		long start = (sourcePosition >>> 32);
-		long end = (sourcePosition & 0x00000000FFFFFFFFL);
-		start = newSourceStart;
-		end = newSourceStart;
-		return ((start<<32)+end); 
+	/** See {@link FieldReference#nameSourcePosition} for explanation */
+	private long recalcSourcePosition(long sourcePosition) {
+//		long start = (sourcePosition >>> 32);
+//		long end = (sourcePosition & 0x00000000FFFFFFFFL);
+//		start = newSourceStart;
+//		end = newSourceStart;
+//		return ((start<<32)+end); 
+		return ((long)newSourceStart << 32) | (newSourceStart & INT_TO_LONG_MASK);
 	}
 	
 	@Override public boolean visit(AllocationExpression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, this.newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 
 	@Override public boolean visit(AND_AND_Expression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, this.newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(AnnotationMethodDeclaration node, ClassScope classScope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, this.newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, classScope);
 	}
 
 	@Override public boolean visit(Argument node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetVariable(node, this.newSourceStart, newSourceEnd);
+		applyOffsetVariable(node);
 		return super.visit(node, scope);
 	}
 
 	@Override public boolean visit(Argument node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetVariable(node, this.newSourceStart, newSourceEnd);
+		applyOffsetVariable(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ArrayAllocationExpression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, this.newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ArrayInitializer node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, this.newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ArrayQualifiedTypeReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetQualifiedTypeReference(node, this.newSourceStart, newSourceEnd);
+		applyOffsetQualifiedTypeReference(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ArrayQualifiedTypeReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetQualifiedTypeReference(node, this.newSourceStart, newSourceEnd);
+		applyOffsetQualifiedTypeReference(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ArrayReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, this.newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ArrayTypeReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, this.newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ArrayTypeReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, this.newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(AssertStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, this.newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 
 	@Override public boolean visit(Assignment node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(BinaryExpression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(Block node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(BreakStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(CaseStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(CastExpression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(CharLiteral node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ClassLiteralAccess node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(Clinit node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(CompilationUnitDeclaration node, CompilationUnitScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 
 	@Override public boolean visit(CompoundAssignment node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ConditionalExpression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ConstructorDeclaration node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ContinueStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(DoStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(DoubleLiteral node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(EmptyStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(EqualExpression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ExplicitConstructorCall node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ExtendedStringLiteral node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(FalseLiteral node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(FieldDeclaration node, MethodScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetFieldDeclaration(node, newSourceStart, newSourceEnd);
+		applyOffsetFieldDeclaration(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(FieldReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetFieldReference(node, newSourceStart, newSourceEnd);
+		applyOffsetFieldReference(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(FieldReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetFieldReference(node, newSourceStart, newSourceEnd);
+		applyOffsetFieldReference(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(FloatLiteral node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ForeachStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ForStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(IfStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ImportReference node, CompilationUnitScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(Initializer node, MethodScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(InstanceOfExpression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(IntLiteral node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(Javadoc node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 
 	@Override public boolean visit(Javadoc node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocAllocationExpression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocAllocationExpression node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocArgumentExpression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocArgumentExpression node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocArrayQualifiedTypeReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocArrayQualifiedTypeReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocArraySingleTypeReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocArraySingleTypeReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocFieldReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocFieldReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocImplicitTypeReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocImplicitTypeReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocMessageSend node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocMessageSend node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocQualifiedTypeReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocQualifiedTypeReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocReturnStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocReturnStatement node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocSingleNameReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocSingleNameReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocSingleTypeReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(JavadocSingleTypeReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(LabeledStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(LocalDeclaration node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetVariable(node, newSourceStart, newSourceEnd);
+		applyOffsetVariable(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(LongLiteral node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(MarkerAnnotation node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(MemberValuePair node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(MessageSend node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetMessageSend(node, newSourceStart, newSourceEnd);
+		applyOffsetMessageSend(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(MethodDeclaration node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(StringLiteralConcatenation node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(NormalAnnotation node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(NullLiteral node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(OR_OR_Expression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ParameterizedQualifiedTypeReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetQualifiedTypeReference(node, newSourceStart, newSourceEnd);
+		applyOffsetQualifiedTypeReference(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ParameterizedQualifiedTypeReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetQualifiedTypeReference(node, newSourceStart, newSourceEnd);
+		applyOffsetQualifiedTypeReference(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ParameterizedSingleTypeReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ParameterizedSingleTypeReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(PostfixExpression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(PrefixExpression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(QualifiedAllocationExpression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(QualifiedNameReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(QualifiedNameReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(QualifiedSuperReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(QualifiedSuperReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(QualifiedThisReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(QualifiedThisReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(QualifiedTypeReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetQualifiedTypeReference(node, newSourceStart, newSourceEnd);
+		applyOffsetQualifiedTypeReference(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(QualifiedTypeReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetQualifiedTypeReference(node, newSourceStart, newSourceEnd);
+		applyOffsetQualifiedTypeReference(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ReturnStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(SingleMemberAnnotation node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(SingleNameReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(SingleNameReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(SingleTypeReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(SingleTypeReference node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(StringLiteral node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(SuperReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(SwitchStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		node.blockStart = newSourceStart;
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(SynchronizedStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(ThisReference node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
@@ -906,73 +908,73 @@ public final class SetGeneratedByVisitor extends ASTVisitor {
 	
 	@Override public boolean visit(ThrowStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(TrueLiteral node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(TryStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(TypeDeclaration node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(TypeDeclaration node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(TypeDeclaration node, CompilationUnitScope scope) {
 		setGeneratedBy(node, source);
-		applyOffset(node, newSourceStart, newSourceEnd);
+		applyOffset(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(TypeParameter node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetVariable(node, newSourceStart, newSourceEnd);
+		applyOffsetVariable(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(TypeParameter node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetVariable(node, newSourceStart, newSourceEnd);
+		applyOffsetVariable(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(UnaryExpression node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(WhileStatement node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetASTNode(node, newSourceStart, newSourceEnd);
+		applyOffsetASTNode(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(Wildcard node, BlockScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 	
 	@Override public boolean visit(Wildcard node, ClassScope scope) {
 		setGeneratedBy(node, source);
-		applyOffsetExpression(node, newSourceStart, newSourceEnd);
+		applyOffsetExpression(node);
 		return super.visit(node, scope);
 	}
 }
\ No newline at end of file