Bug 574803 - [content assist] no content assist in if expression before

variable declaration

Change-Id: Ie10ebc114a6e4e08a790fe380df600cc5d70bb3d
Reviewed-on: https://git.eclipse.org/r/c/jdt/eclipse.jdt.core/+/183569
Tested-by: JDT Bot <jdt-bot@eclipse.org>
Reviewed-by: Stephan Herrmann <stephan.herrmann@berlin.de>

8 files changed, 863 insertions, 30 deletions

diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionRecoveryTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionRecoveryTest.java
index 03235db715..a88209d57b 100644
--- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionRecoveryTest.java
+++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/parser/CompletionRecoveryTest.java
@@ -758,6 +758,7 @@ public void test18() {
 		"      int hello() {\n" +
 		"      }\n" +
 		"    }\n" +
+		"    <CompleteOnName:>;\n" +
 		"  }\n" +
 		"}\n",
 		// expectedCompletionIdentifier:
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CompletionTests3.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CompletionTests3.java
index c0ebd5bb2e..ba9d3ee5ac 100644
--- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CompletionTests3.java
+++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CompletionTests3.java
@@ -1004,4 +1004,38 @@ public void testBug574704_withPrefix() throws Exception {
 		deleteProject("P");
 	}
 }
+public void testBug574803() throws Exception {
+	try {
+		createJavaProject("P", new String[] {"src"}, new String[]{"JCL17_LIB"}, "bin", "1.7");
+		this.workingCopies = new ICompilationUnit[2];
+		this.workingCopies[0] = getWorkingCopy(
+			"/P/src/X.java",
+			"public class X {\n" +
+			"\n" +
+			"	\n" +
+			"	public static void fillAttributes(Object object) throws Exception {\n" +
+			"		for (Field field : object.getClass().getFields()) {\n" +
+			"			if (field.getType() == ) // no content assist\n" +
+			"			Object value = field.get(object);\n" +
+			"			System.out.println(value);\n" +
+			"		}\n" +
+			"	}\n" +
+			"}\n");
+
+		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
+		String str = this.workingCopies[0].getSource();
+		String completeAfter = "field.getType() == ";
+		int cursorLocation = str.indexOf(completeAfter) + completeAfter.length();
+		this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
+		int relevance = R_DEFAULT + R_INTERESTING + R_RESOLVED + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED;
+		assertResults(
+				"X[TYPE_REF]{X, , LX;, null, null, " + relevance + "}\n" +
+				"field[LOCAL_VARIABLE_REF]{field, null, LField;, field, null, " + relevance + "}\n" +
+				"fillAttributes[METHOD_REF]{fillAttributes(), LX;, (Ljava.lang.Object;)V, fillAttributes, (object), " + relevance + "}\n" +
+				"object[LOCAL_VARIABLE_REF]{object, null, Ljava.lang.Object;, object, null, " + relevance + "}",
+				requestor.getResults());
+	} finally {
+		deleteProject("P");
+	}
+}
 }
diff --git a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java
index 44c68ce644..11a5b46ac9 100644
--- a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java
+++ b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java
@@ -66,8 +66,9 @@ import org.eclipse.jdt.internal.codeassist.complete.CompletionNodeDetector;
 import org.eclipse.jdt.internal.codeassist.complete.CompletionNodeFound;
 import org.eclipse.jdt.internal.codeassist.complete.CompletionOnAnnotationOfType;
 import org.eclipse.jdt.internal.codeassist.complete.CompletionOnArgumentName;
-import org.eclipse.jdt.internal.codeassist.complete.CompletionOnBranchStatementLabel;
+import org.eclipse.jdt.internal.codeassist.complete.CompletionOnBreakStatement;
 import org.eclipse.jdt.internal.codeassist.complete.CompletionOnClassLiteralAccess;
+import org.eclipse.jdt.internal.codeassist.complete.CompletionOnContinueStatement;
 import org.eclipse.jdt.internal.codeassist.complete.CompletionOnExplicitConstructorCall;
 import org.eclipse.jdt.internal.codeassist.complete.CompletionOnFieldName;
 import org.eclipse.jdt.internal.codeassist.complete.CompletionOnFieldType;
@@ -2015,8 +2016,10 @@ public final class CompletionEngine
 			completionOnMarkerAnnotationName(astNode, qualifiedBinding, scope);
 		} else if (astNode instanceof CompletionOnMemberValueName) {
 			completionOnMemberValueName(astNode, astNodeParent, scope, insideTypeAnnotation);
-		} else if(astNode instanceof CompletionOnBranchStatementLabel) {
-			completionOnBranchStatementLabel(astNode);
+		} else if(astNode instanceof CompletionOnBreakStatement) {
+			completionOnBreakStatement((CompletionOnBreakStatement) astNode);
+		} else if(astNode instanceof CompletionOnContinueStatement) {
+			completionOnContinueStatement((CompletionOnContinueStatement) astNode);
 		} else if(astNode instanceof CompletionOnMessageSendName) {
 			completionOnMessageSendName(astNode, qualifiedBinding, scope);
 		} else if (astNode instanceof CompletionOnReferenceExpressionName) {
@@ -2598,11 +2601,17 @@ public final class CompletionEngine
 		}
 	}
 
-	private void completionOnBranchStatementLabel(ASTNode astNode) {
+	private void completionOnBreakStatement(CompletionOnBreakStatement astNode) {
 		if (!this.requestor.isIgnored(CompletionProposal.LABEL_REF)) {
-			CompletionOnBranchStatementLabel label = (CompletionOnBranchStatementLabel) astNode;
-			this.completionToken = label.label;
-			findLabels(this.completionToken, label.possibleLabels);
+			this.completionToken = astNode.label;
+			findLabels(this.completionToken, astNode.possibleLabels);
+		}
+	}
+
+	private void completionOnContinueStatement(CompletionOnContinueStatement astNode) {
+		if (!this.requestor.isIgnored(CompletionProposal.LABEL_REF)) {
+			this.completionToken = astNode.label;
+			findLabels(this.completionToken, astNode.possibleLabels);
 		}
 	}
 
diff --git a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionNodeDetector.java b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionNodeDetector.java
index 929cbe1c7a..b1599822aa 100644
--- a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionNodeDetector.java
+++ b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionNodeDetector.java
@@ -24,6 +24,29 @@ import org.eclipse.jdt.internal.compiler.lookup.*;
  */
 public class CompletionNodeDetector extends ASTVisitor {
 
+	static class FindAny extends GenericAstVisitor {
+		private ASTNode searchFor;
+		boolean found;
+
+		public FindAny(ASTNode searchFor) {
+			this.searchFor = searchFor;
+		}
+
+		@Override
+		protected boolean visitNode(ASTNode node) {
+			if (node == this.searchFor) {
+				this.found = true;
+				return false;
+			}
+			return true;
+		}
+	}
+	public static boolean findAny(CompilationUnitDeclaration unit, ASTNode searchFor) {
+		FindAny visitor = new FindAny(searchFor);
+		unit.traverse(visitor, (CompilationUnitScope)null, false);
+		return visitor.found;
+	}
+
 	@SuppressWarnings("serial")
 	static class StopTraversal extends RuntimeException { /* no details */}
 
diff --git a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnBranchStatementLabel.java b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnBreakStatement.java
index b83605e175..780c117fa4 100644
--- a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnBranchStatementLabel.java
+++ b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnBreakStatement.java
@@ -13,21 +13,17 @@
  *******************************************************************************/
 package org.eclipse.jdt.internal.codeassist.complete;
 
-import org.eclipse.jdt.internal.compiler.ast.BranchStatement;
+import org.eclipse.jdt.internal.compiler.ast.BreakStatement;
 import org.eclipse.jdt.internal.compiler.flow.FlowContext;
 import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
 
-public class CompletionOnBranchStatementLabel extends BranchStatement {
-	public static final int BREAK = 1;
-	public static final int CONTINUE = 2;
+public class CompletionOnBreakStatement extends BreakStatement {
 
-	private int kind;
 	public char[][] possibleLabels;
 
-	public CompletionOnBranchStatementLabel(int kind, char[] l, int s, int e, char[][] possibleLabels) {
+	public CompletionOnBreakStatement(char[] l, int s, int e, char[][] possibleLabels) {
 		super(l, s, e);
-		this.kind = kind;
 		this.possibleLabels = possibleLabels;
 	}
 
@@ -45,14 +41,9 @@ public class CompletionOnBranchStatementLabel extends BranchStatement {
 	@Override
 	public StringBuffer printStatement(int indent, StringBuffer output) {
 		printIndent(indent, output);
-		if(this.kind == CONTINUE) {
-			output.append("continue "); //$NON-NLS-1$
-		} else {
-			output.append("break "); //$NON-NLS-1$
-		}
+		output.append("break "); //$NON-NLS-1$
 		output.append("<CompleteOnLabel:"); //$NON-NLS-1$
 		output.append(this.label);
 		return output.append(">;"); //$NON-NLS-1$
 	}
-
 }
diff --git a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnContinueStatement.java b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnContinueStatement.java
new file mode 100644
index 0000000000..5ebf7d42fb
--- /dev/null
+++ b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnContinueStatement.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * Copyright (c) 2005, 2021 IBM Corporation and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.codeassist.complete;
+
+import org.eclipse.jdt.internal.compiler.ast.ContinueStatement;
+import org.eclipse.jdt.internal.compiler.flow.FlowContext;
+import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
+import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
+
+public class CompletionOnContinueStatement extends ContinueStatement {
+
+	public char[][] possibleLabels;
+
+	public CompletionOnContinueStatement(char[] l, int s, int e, char[][] possibleLabels) {
+		super(l, s, e);
+		this.possibleLabels = possibleLabels;
+	}
+
+	@Override
+	public FlowInfo analyseCode(BlockScope currentScope,
+			FlowContext flowContext, FlowInfo flowInfo) {
+		// Is never called
+		return null;
+	}
+
+	@Override
+	public void resolve(BlockScope scope) {
+		throw new CompletionNodeFound(this, scope);
+	}
+	@Override
+	public StringBuffer printStatement(int indent, StringBuffer output) {
+		printIndent(indent, output);
+		output.append("continue "); //$NON-NLS-1$
+		output.append("<CompleteOnLabel:"); //$NON-NLS-1$
+		output.append(this.label);
+		return output.append(">;"); //$NON-NLS-1$
+	}
+}
diff --git a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java
index 277ea02711..0d1eea0664 100644
--- a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java
+++ b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java
@@ -1978,15 +1978,17 @@ private boolean checkLabelStatement() {
 		System.arraycopy(labels, 0, labels = new char[labelCount][], 0, labelCount);
 
 		long position = this.identifierPositionStack[this.identifierPtr];
-		CompletionOnBranchStatementLabel statementLabel =
-			new CompletionOnBranchStatementLabel(
-					kind == K_INSIDE_BREAK_STATEMENT ? CompletionOnBranchStatementLabel.BREAK : CompletionOnBranchStatementLabel.CONTINUE,
-					this.identifierStack[this.identifierPtr--],
-					(int) (position >>> 32),
-					(int)position,
-					labels);
-
-		this.assistNode = statementLabel;
+		this.assistNode = kind == K_INSIDE_BREAK_STATEMENT
+				? new CompletionOnBreakStatement(
+						this.identifierStack[this.identifierPtr--],
+						(int) (position >>> 32),
+						(int)position,
+						labels)
+				: new CompletionOnContinueStatement(
+						this.identifierStack[this.identifierPtr--],
+						(int) (position >>> 32),
+						(int)position,
+						labels);
 		this.lastCheckPoint = this.assistNode.sourceEnd + 1;
 		this.isOrphanCompletionNode = true;
 		return true;
@@ -6141,10 +6143,23 @@ protected CompilationUnitDeclaration endParse(int act) {
 				statement = (Statement) this.assistNode;
 			}
 			AbstractMethodDeclaration method = (AbstractMethodDeclaration) this.referenceContext;
-			if (statement != null && isInsideBody(statement, method)) {
+			if (statement != null && isInsideBody(statement, method)
+					&& this.assistNode != null && !CompletionNodeDetector.findAny(cud, statement))
+			{
 				// automaton ended right before transferring statements into the method?
 				if (method.statements == null) {
 					method.statements = new Statement[] { statement };
+				} else if (this.currentElement != null) {
+					// or before transferring statements into a nested recovered element?
+					this.currentElement.add(statement, 0);
+					RecoveredElement element = this.currentElement;
+					while (element != null) {
+						if (element instanceof RecoveredMethod && ((RecoveredMethod) element).methodDeclaration == method) {
+							element.updateParseTree();
+							break;
+						}
+						element = element.parent;
+					}
 				}
 			}
 		}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/GenericAstVisitor.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/GenericAstVisitor.java
new file mode 100644
index 0000000000..eb8f6df1c9
--- /dev/null
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/GenericAstVisitor.java
@@ -0,0 +1,711 @@
+/*******************************************************************************
+ * Copyright (c) 2021 GK Software SE and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Stephan Herrmann - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.compiler;
+
+import org.eclipse.jdt.internal.compiler.ast.*;
+import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
+import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
+import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;
+import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
+
+public abstract class GenericAstVisitor extends ASTVisitor {
+
+	// override this to handle all nodes:
+	protected abstract boolean visitNode(ASTNode node);
+
+	@Override
+	public boolean visit(AllocationExpression allocationExpression, BlockScope scope) {
+		return visitNode(allocationExpression);
+	}
+
+	@Override
+	public boolean visit(AND_AND_Expression and_and_Expression, BlockScope scope) {
+		return visitNode(and_and_Expression);
+	}
+
+	@Override
+	public boolean visit(AnnotationMethodDeclaration annotationTypeDeclaration, ClassScope classScope) {
+		return visitNode(annotationTypeDeclaration);
+	}
+
+	@Override
+	public boolean visit(Argument argument, BlockScope scope) {
+		return visitNode(argument);
+	}
+
+	@Override
+	public boolean visit(Argument argument, ClassScope scope) {
+		return visitNode(argument);
+	}
+
+	@Override
+	public boolean visit(ArrayAllocationExpression arrayAllocationExpression, BlockScope scope) {
+		return visitNode(arrayAllocationExpression);
+	}
+
+	@Override
+	public boolean visit(ArrayInitializer arrayInitializer, BlockScope scope) {
+		return visitNode(arrayInitializer);
+	}
+
+	@Override
+	public boolean visit(ArrayInitializer arrayInitializer, ClassScope scope) {
+		return visitNode(arrayInitializer);
+	}
+
+	@Override
+	public boolean visit(ArrayQualifiedTypeReference arrayQualifiedTypeReference, BlockScope scope) {
+		return visitNode(arrayQualifiedTypeReference);
+	}
+
+	@Override
+	public boolean visit(ArrayQualifiedTypeReference arrayQualifiedTypeReference, ClassScope scope) {
+		return visitNode(arrayQualifiedTypeReference);
+	}
+
+	@Override
+	public boolean visit(ArrayReference arrayReference, BlockScope scope) {
+		return visitNode(arrayReference);
+	}
+
+	@Override
+	public boolean visit(ArrayTypeReference arrayTypeReference, BlockScope scope) {
+		return visitNode(arrayTypeReference);
+	}
+
+	@Override
+	public boolean visit(ArrayTypeReference arrayTypeReference, ClassScope scope) {
+		return visitNode(arrayTypeReference);
+	}
+
+	@Override
+	public boolean visit(AssertStatement assertStatement, BlockScope scope) {
+		return visitNode(assertStatement);
+	}
+
+	@Override
+	public boolean visit(Assignment assignment, BlockScope scope) {
+		return visitNode(assignment);
+	}
+
+	@Override
+	public boolean visit(BinaryExpression binaryExpression, BlockScope scope) {
+		return visitNode(binaryExpression);
+	}
+
+	@Override
+	public boolean visit(Block block, BlockScope scope) {
+		return visitNode(block);
+	}
+
+	@Override
+	public boolean visit(BreakStatement breakStatement, BlockScope scope) {
+		return visitNode(breakStatement);
+	}
+
+	@Override
+	public boolean visit(CaseStatement caseStatement, BlockScope scope) {
+		return visitNode(caseStatement);
+	}
+
+	@Override
+	public boolean visit(CastExpression castExpression, BlockScope scope) {
+		return visitNode(castExpression);
+	}
+
+	@Override
+	public boolean visit(CharLiteral charLiteral, BlockScope scope) {
+		return visitNode(charLiteral);
+	}
+
+	@Override
+	public boolean visit(ClassLiteralAccess classLiteral, BlockScope scope) {
+		return visitNode(classLiteral);
+	}
+
+	@Override
+	public boolean visit(Clinit clinit, ClassScope scope) {
+		return visitNode(clinit);
+	}
+
+	@Override
+	public boolean visit(ModuleDeclaration module, CompilationUnitScope scope) {
+		return visitNode(module);
+	}
+
+	@Override
+	public boolean visit(CompactConstructorDeclaration ccd, ClassScope scope) {
+		return visitNode(ccd);
+	}
+
+	@Override
+	public boolean visit(CompilationUnitDeclaration compilationUnitDeclaration, CompilationUnitScope scope) {
+		return visitNode(compilationUnitDeclaration);
+	}
+
+	@Override
+	public boolean visit(CompoundAssignment compoundAssignment, BlockScope scope) {
+		return visitNode(compoundAssignment);
+	}
+
+	@Override
+	public boolean visit(ConditionalExpression conditionalExpression, BlockScope scope) {
+		return visitNode(conditionalExpression);
+	}
+
+	@Override
+	public boolean visit(ConstructorDeclaration constructorDeclaration, ClassScope scope) {
+		return visitNode(constructorDeclaration);
+	}
+
+	@Override
+	public boolean visit(ContinueStatement continueStatement, BlockScope scope) {
+		return visitNode(continueStatement);
+	}
+
+	@Override
+	public boolean visit(DoStatement doStatement, BlockScope scope) {
+		return visitNode(doStatement);
+	}
+
+	@Override
+	public boolean visit(DoubleLiteral doubleLiteral, BlockScope scope) {
+		return visitNode(doubleLiteral);
+	}
+
+	@Override
+	public boolean visit(EmptyStatement emptyStatement, BlockScope scope) {
+		return visitNode(emptyStatement);
+	}
+
+	@Override
+	public boolean visit(EqualExpression equalExpression, BlockScope scope) {
+		return visitNode(equalExpression);
+	}
+
+	@Override
+	public boolean visit(ExplicitConstructorCall explicitConstructor, BlockScope scope) {
+		return visitNode(explicitConstructor);
+	}
+
+	@Override
+	public boolean visit(ExtendedStringLiteral extendedStringLiteral, BlockScope scope) {
+		return visitNode(extendedStringLiteral);
+	}
+
+	@Override
+	public boolean visit(FalseLiteral falseLiteral, BlockScope scope) {
+		return visitNode(falseLiteral);
+	}
+
+	@Override
+	public boolean visit(FieldDeclaration fieldDeclaration, MethodScope scope) {
+		return visitNode(fieldDeclaration);
+	}
+
+	@Override
+	public boolean visit(FieldReference fieldReference, BlockScope scope) {
+		return visitNode(fieldReference);
+	}
+
+	@Override
+	public boolean visit(FieldReference fieldReference, ClassScope scope) {
+		return visitNode(fieldReference);
+	}
+
+	@Override
+	public boolean visit(FloatLiteral floatLiteral, BlockScope scope) {
+		return visitNode(floatLiteral);
+	}
+
+	@Override
+	public boolean visit(ForeachStatement forStatement, BlockScope scope) {
+		return visitNode(forStatement);
+	}
+
+	@Override
+	public boolean visit(ForStatement forStatement, BlockScope scope) {
+		return visitNode(forStatement);
+	}
+
+	@Override
+	public boolean visit(IfStatement ifStatement, BlockScope scope) {
+		return visitNode(ifStatement);
+	}
+
+	@Override
+	public boolean visit(ImportReference importRef, CompilationUnitScope scope) {
+		return visitNode(importRef);
+	}
+
+	@Override
+	public boolean visit(Initializer initializer, MethodScope scope) {
+		return visitNode(initializer);
+	}
+
+	@Override
+	public boolean visit(InstanceOfExpression instanceOfExpression, BlockScope scope) {
+		return visitNode(instanceOfExpression);
+	}
+
+	@Override
+	public boolean visit(IntLiteral intLiteral, BlockScope scope) {
+		return visitNode(intLiteral);
+	}
+
+	@Override
+	public boolean visit(Javadoc javadoc, BlockScope scope) {
+		return visitNode(javadoc);
+	}
+
+	@Override
+	public boolean visit(Javadoc javadoc, ClassScope scope) {
+		return visitNode(javadoc);
+	}
+
+	@Override
+	public boolean visit(JavadocAllocationExpression expression, BlockScope scope) {
+		return visitNode(expression);
+	}
+
+	@Override
+	public boolean visit(JavadocAllocationExpression expression, ClassScope scope) {
+		return visitNode(expression);
+	}
+
+	@Override
+	public boolean visit(JavadocArgumentExpression expression, BlockScope scope) {
+		return visitNode(expression);
+	}
+
+	@Override
+	public boolean visit(JavadocArgumentExpression expression, ClassScope scope) {
+		return visitNode(expression);
+	}
+
+	@Override
+	public boolean visit(JavadocArrayQualifiedTypeReference typeRef, BlockScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(JavadocArrayQualifiedTypeReference typeRef, ClassScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(JavadocArraySingleTypeReference typeRef, BlockScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(JavadocArraySingleTypeReference typeRef, ClassScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(JavadocFieldReference fieldRef, BlockScope scope) {
+		return visitNode(fieldRef);
+	}
+
+	@Override
+	public boolean visit(JavadocFieldReference fieldRef, ClassScope scope) {
+		return visitNode(fieldRef);
+	}
+
+	@Override
+	public boolean visit(JavadocImplicitTypeReference implicitTypeReference, BlockScope scope) {
+		return visitNode(implicitTypeReference);
+	}
+
+	@Override
+	public boolean visit(JavadocImplicitTypeReference implicitTypeReference, ClassScope scope) {
+		return visitNode(implicitTypeReference);
+	}
+
+	@Override
+	public boolean visit(JavadocMessageSend messageSend, BlockScope scope) {
+		return visitNode(messageSend);
+	}
+
+	@Override
+	public boolean visit(JavadocMessageSend messageSend, ClassScope scope) {
+		return visitNode(messageSend);
+	}
+
+	@Override
+	public boolean visit(JavadocQualifiedTypeReference typeRef, BlockScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(JavadocQualifiedTypeReference typeRef, ClassScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(JavadocModuleReference moduleRef, BlockScope scope) {
+		return visitNode(moduleRef);
+	}
+
+	@Override
+	public boolean visit(JavadocModuleReference moduleRef, ClassScope scope) {
+		return visitNode(moduleRef);
+	}
+
+	@Override
+	public boolean visit(JavadocReturnStatement statement, BlockScope scope) {
+		return visitNode(statement);
+	}
+
+	@Override
+	public boolean visit(JavadocReturnStatement statement, ClassScope scope) {
+		return visitNode(statement);
+	}
+
+	@Override
+	public boolean visit(JavadocSingleNameReference argument, BlockScope scope) {
+		return visitNode(argument);
+	}
+
+	@Override
+	public boolean visit(JavadocSingleNameReference argument, ClassScope scope) {
+		return visitNode(argument);
+	}
+
+	@Override
+	public boolean visit(JavadocSingleTypeReference typeRef, BlockScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(JavadocSingleTypeReference typeRef, ClassScope scope) {
+		return visitNode(typeRef);
+	}
+
+	@Override
+	public boolean visit(LabeledStatement labeledStatement, BlockScope scope) {
+		return visitNode(labeledStatement);
+	}
+
+	@Override
+	public boolean visit(LocalDeclaration localDeclaration, BlockScope scope) {
+		return visitNode(localDeclaration);
+	}
+
+	@Override
+	public boolean visit(LongLiteral longLiteral, BlockScope scope) {
+		return visitNode(longLiteral);
+	}
+
+	@Override
+	public boolean visit(MarkerAnnotation annotation, BlockScope scope) {
+		return visitNode(annotation);
+	}
+
+	@Override
+	public boolean visit(MarkerAnnotation annotation, ClassScope scope) {
+		return visitNode(annotation);
+	}
+
+	@Override
+	public boolean visit(MemberValuePair pair, BlockScope scope) {
+		return visitNode(pair);
+	}
+
+	@Override
+	public boolean visit(MemberValuePair pair, ClassScope scope) {
+		return visitNode(pair);
+	}
+
+	@Override
+	public boolean visit(MessageSend messageSend, BlockScope scope) {
+		return visitNode(messageSend);
+	}
+
+	@Override
+	public boolean visit(MethodDeclaration methodDeclaration, ClassScope scope) {
+		return visitNode(methodDeclaration);
+	}
+
+	@Override
+	public boolean visit(StringLiteralConcatenation literal, BlockScope scope) {
+		return visitNode(literal);
+	}
+
+	@Override
+	public boolean visit(NormalAnnotation annotation, BlockScope scope) {
+		return visitNode(annotation);
+	}
+
+	@Override
+	public boolean visit(NormalAnnotation annotation, ClassScope scope) {
+		return visitNode(annotation);
+	}
+
+	@Override
+	public boolean visit(NullLiteral nullLiteral, BlockScope scope) {
+		return visitNode(nullLiteral);
+	}
+
+	@Override
+	public boolean visit(OR_OR_Expression or_or_Expression, BlockScope scope) {
+		return visitNode(or_or_Expression);
+	}
+
+	@Override
+	public boolean visit(ParameterizedQualifiedTypeReference parameterizedQualifiedTypeReference, BlockScope scope) {
+		return visitNode(parameterizedQualifiedTypeReference);
+	}
+
+	@Override
+	public boolean visit(ParameterizedQualifiedTypeReference parameterizedQualifiedTypeReference, ClassScope scope) {
+		return visitNode(parameterizedQualifiedTypeReference);
+	}
+
+	@Override
+	public boolean visit(ParameterizedSingleTypeReference parameterizedSingleTypeReference, BlockScope scope) {
+		return visitNode(parameterizedSingleTypeReference);
+	}
+
+	@Override
+	public boolean visit(ParameterizedSingleTypeReference parameterizedSingleTypeReference, ClassScope scope) {
+		return visitNode(parameterizedSingleTypeReference);
+	}
+
+	@Override
+	public boolean visit(PostfixExpression postfixExpression, BlockScope scope) {
+		return visitNode(postfixExpression);
+	}
+
+	@Override
+	public boolean visit(PrefixExpression prefixExpression, BlockScope scope) {
+		return visitNode(prefixExpression);
+	}
+
+	@Override
+	public boolean visit(QualifiedAllocationExpression qualifiedAllocationExpression, BlockScope scope) {
+		return visitNode(qualifiedAllocationExpression);
+	}
+
+	@Override
+	public boolean visit(QualifiedNameReference qualifiedNameReference, BlockScope scope) {
+		return visitNode(qualifiedNameReference);
+	}
+
+	@Override
+	public boolean visit(QualifiedNameReference qualifiedNameReference, ClassScope scope) {
+		return visitNode(qualifiedNameReference);
+	}
+
+	@Override
+	public boolean visit(QualifiedSuperReference qualifiedSuperReference, BlockScope scope) {
+		return visitNode(qualifiedSuperReference);
+	}
+
+	@Override
+	public boolean visit(QualifiedSuperReference qualifiedSuperReference, ClassScope scope) {
+		return visitNode(qualifiedSuperReference);
+	}
+
+	@Override
+	public boolean visit(QualifiedThisReference qualifiedThisReference, BlockScope scope) {
+		return visitNode(qualifiedThisReference);
+	}
+
+	@Override
+	public boolean visit(QualifiedThisReference qualifiedThisReference, ClassScope scope) {
+		return visitNode(qualifiedThisReference);
+	}
+
+	@Override
+	public boolean visit(QualifiedTypeReference qualifiedTypeReference, BlockScope scope) {
+		return visitNode(qualifiedTypeReference);
+	}
+
+	@Override
+	public boolean visit(QualifiedTypeReference qualifiedTypeReference, ClassScope scope) {
+		return visitNode(qualifiedTypeReference);
+	}
+
+	@Override
+	public boolean visit(ReturnStatement returnStatement, BlockScope scope) {
+		return visitNode(returnStatement);
+	}
+
+	@Override
+	public boolean visit(SingleMemberAnnotation annotation, BlockScope scope) {
+		return visitNode(annotation);
+	}
+
+	@Override
+	public boolean visit(SingleMemberAnnotation annotation, ClassScope scope) {
+		return visitNode(annotation);
+	}
+
+	@Override
+	public boolean visit(SingleNameReference singleNameReference, BlockScope scope) {
+		return visitNode(singleNameReference);
+	}
+
+	@Override
+	public boolean visit(SingleNameReference singleNameReference, ClassScope scope) {
+		return visitNode(singleNameReference);
+	}
+
+	@Override
+	public boolean visit(SingleTypeReference singleTypeReference, BlockScope scope) {
+		return visitNode(singleTypeReference);
+	}
+
+	@Override
+	public boolean visit(SingleTypeReference singleTypeReference, ClassScope scope) {
+		return visitNode(singleTypeReference);
+	}
+
+	@Override
+	public boolean visit(StringLiteral stringLiteral, BlockScope scope) {
+		return visitNode(stringLiteral);
+	}
+
+	@Override
+	public boolean visit(SuperReference superReference, BlockScope scope) {
+		return visitNode(superReference);
+	}
+
+	@Override
+	public boolean visit(SwitchStatement switchStatement, BlockScope scope) {
+		return visitNode(switchStatement);
+	}
+
+	@Override
+	public boolean visit(SynchronizedStatement synchronizedStatement, BlockScope scope) {
+		return visitNode(synchronizedStatement);
+	}
+
+	@Override
+	public boolean visit(ThisReference thisReference, BlockScope scope) {
+		return visitNode(thisReference);
+	}
+
+	@Override
+	public boolean visit(ThisReference thisReference, ClassScope scope) {
+		return visitNode(thisReference);
+	}
+
+	@Override
+	public boolean visit(ThrowStatement throwStatement, BlockScope scope) {
+		return visitNode(throwStatement);
+	}
+
+	@Override
+	public boolean visit(TrueLiteral trueLiteral, BlockScope scope) {
+		return visitNode(trueLiteral);
+	}
+
+	@Override
+	public boolean visit(TryStatement tryStatement, BlockScope scope) {
+		return visitNode(tryStatement);
+	}
+
+	@Override
+	public boolean visit(TypeDeclaration localTypeDeclaration, BlockScope scope) {
+		return visitNode(localTypeDeclaration);
+	}
+
+	@Override
+	public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope scope) {
+		return visitNode(memberTypeDeclaration);
+	}
+
+	@Override
+	public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope scope) {
+		return visitNode(typeDeclaration);
+	}
+
+	@Override
+	public boolean visit(TypeParameter typeParameter, BlockScope scope) {
+		return visitNode(typeParameter);
+	}
+
+	@Override
+	public boolean visit(TypeParameter typeParameter, ClassScope scope) {
+		return visitNode(typeParameter);
+	}
+
+	@Override
+	public boolean visit(UnaryExpression unaryExpression, BlockScope scope) {
+		return visitNode(unaryExpression);
+	}
+
+	@Override
+	public boolean visit(UnionTypeReference unionTypeReference, BlockScope scope) {
+		return visitNode(unionTypeReference);
+	}
+
+	@Override
+	public boolean visit(UnionTypeReference unionTypeReference, ClassScope scope) {
+		return visitNode(unionTypeReference);
+	}
+
+	@Override
+	public boolean visit(YieldStatement yieldStatement, BlockScope scope) {
+		return visitNode(yieldStatement);
+	}
+
+	@Override
+	public boolean visit(WhileStatement whileStatement, BlockScope scope) {
+		return visitNode(whileStatement);
+	}
+
+	@Override
+	public boolean visit(Wildcard wildcard, BlockScope scope) {
+		return visitNode(wildcard);
+	}
+
+	@Override
+	public boolean visit(Wildcard wildcard, ClassScope scope) {
+		return visitNode(wildcard);
+	}
+
+	@Override
+	public boolean visit(LambdaExpression lambdaExpression, BlockScope blockScope) {
+		return visitNode(lambdaExpression);
+	}
+
+	@Override
+	public boolean visit(ReferenceExpression referenceExpression, BlockScope blockScope) {
+		return visitNode(referenceExpression);
+	}
+
+	@Override
+	public boolean visit(IntersectionCastTypeReference intersectionCastTypeReference, ClassScope scope) {
+		return visitNode(intersectionCastTypeReference);
+	}
+
+	@Override
+	public boolean visit(IntersectionCastTypeReference intersectionCastTypeReference, BlockScope scope) {
+		return visitNode(intersectionCastTypeReference);
+	}
+
+	@Override
+	public boolean visit(SwitchExpression switchExpression, BlockScope blockScope) {
+		return visitNode(switchExpression);
+	}
+
+	@Override
+	public boolean visit(RecordComponent recordComponent, BlockScope scope) {
+		return visitNode(recordComponent);
+	}
+}