Attachment #48948 for bug #155423

View | Details | Raw Unified | Return to bug 155423
Collapse All | Expand All

Lines 10-19 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/FlowAnalysisTest.java (+254 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.core.tests.compiler.regression;	11	package org.eclipse.jdt.core.tests.compiler.regression;
12		12
		13	import java.io.File;
		14	import java.io.IOException;
13	import java.util.Map;	15	import java.util.Map;
14		16
		17	import org.eclipse.jdt.core.ToolFactory;
15	import org.eclipse.jdt.core.compiler.CategorizedProblem;	18	import org.eclipse.jdt.core.compiler.CategorizedProblem;
16	import org.eclipse.jdt.core.compiler.IProblem;	19	import org.eclipse.jdt.core.compiler.IProblem;
		20	import org.eclipse.jdt.core.tests.util.Util;
		21	import org.eclipse.jdt.core.util.ClassFileBytesDisassembler;
17	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;	22	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
18	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;	23	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
19	import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;	24	import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
Lines 777-782 Link Here
777	},	782	},
778	"s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-");	783	"s-s-s-s-s-s-s-s-s-s-s-s-s-s-s-");
779	}	784	}
		785	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=155423
		786	public void test028() {
		787	this.runConformTest(
		788	new String[] {
		789	"X.java",
		790	"public class X {\n" +
		791	" {\n" +
		792	" if (true) throw new NullPointerException();\n" +
		793	" }\n" +
		794	"}\n" // =================
		795	},
		796	"");
		797	// check no default return opcode is appended
		798	String expectedOutput =
		799	" public X();\n" +
		800	" 0 aload_0 [this]\n" +
		801	" 1 invokespecial java.lang.Object() [8]\n" +
		802	" 4 new java.lang.NullPointerException [10]\n" +
		803	" 7 dup\n" +
		804	" 8 invokespecial java.lang.NullPointerException() [12]\n" +
		805	" 11 athrow\n" +
		806	" Line numbers:\n" +
		807	" [pc: 0, line: 1]\n" +
		808	" [pc: 4, line: 3]\n" +
		809	" Local variable table:\n" +
		810	" [pc: 0, pc: 12] local: this index: 0 type: X\n";
		811
		812	try {
		813	File f = new File(OUTPUT_DIR + File.separator + "X.class");
		814	byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
		815	ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
		816	String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
		817	int index = result.indexOf(expectedOutput);
		818	if (index == -1 \|\| expectedOutput.length() == 0) {
		819	System.out.println(Util.displayString(result, 3));
		820	}
		821	if (index == -1) {
		822	assertEquals("Wrong contents", expectedOutput, result);
		823	}
		824	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
		825	assertTrue(false);
		826	} catch (IOException e) {
		827	assertTrue(false);
		828	}
		829	}
		830	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=155423 - variation
		831	public void test029() {
		832	this.runConformTest(
		833	new String[] {
		834	"X.java",
		835	"public class X {\n" +
		836	" {\n" +
		837	" if (true) throw new NullPointerException();\n" +
		838	" }\n" +
		839	" X() {\n" +
		840	" System.out.println();\n" +
		841	" }\n" +
		842	"}\n", // =================
		843	},
		844	"");
		845	// check no default return opcode is appended
		846	String expectedOutput =
		847	" // Method descriptor #6 ()V\n" +
		848	" // Stack: 2, Locals: 1\n" +
849	" X();\n" +
850	" 0 aload_0 [this]\n" +
851	" 1 invokespecial java.lang.Object() [8]\n" +
852	" 4 new java.lang.NullPointerException [10]\n" +
853	" 7 dup\n" +
854	" 8 invokespecial java.lang.NullPointerException() [12]\n" +
855	" 11 athrow\n" +
856	" Line numbers:\n" +
857	" [pc: 0, line: 5]\n" +
858	" [pc: 4, line: 3]\n" +
859	" Local variable table:\n" +
860	" [pc: 0, pc: 12] local: this index: 0 type: X\n";
861
862	try {
863	File f = new File(OUTPUT_DIR + File.separator + "X.class");
864	byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
865	ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
866	String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
867	int index = result.indexOf(expectedOutput);
868	if (index == -1 \|\| expectedOutput.length() == 0) {
869	System.out.println(Util.displayString(result, 3));
870	}
871	if (index == -1) {
872	assertEquals("Wrong contents", expectedOutput, result);
873	}
874	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
875	assertTrue(false);
876	} catch (IOException e) {
877	assertTrue(false);
878	}
879	}
880	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=155423 - variation
881	public void test030() {
882	this.runConformTest(
883	new String[] {
884	"X.java",
885	"class Y {\n" +
886	" Y(Object o) {\n" +
887	" System.out.print(o);\n" +
888	" }\n" +
889	"}\n" +
890	"\n" +
891	"public class X extends Y {\n" +
892	" {\n" +
893	" if (true)\n" +
894	" throw new NullPointerException();\n" +
895	" }\n" +
896	"\n" +
897	" X() {\n" +
898	" super(new Object() {\n" +
899	" public String toString() {\n" +
900	" return \"SUCCESS:\";\n" +
901	" }\n" +
902	" });\n" +
903	" System.out.println();\n" +
904	" }\n" +
905	" public static void main(String[] args) {\n" +
906	" try {\n" +
907	" new X();\n" +
908	" } catch(NullPointerException e) {\n" +
909	" System.out.println(\"caught:NPE\");\n" +
910	" }\n" +
911	" }\n" +
912	"}\n", // =================
913	},
914	"SUCCESS:caught:NPE");
915	// check no default return opcode is appended
916	String expectedOutput =
917	" // Method descriptor #6 ()V\n" +
918	" // Stack: 3, Locals: 1\n" +
919	" X();\n" +
920	" 0 aload_0 [this]\n" +
921	" 1 new X$1 [8]\n" +
922	" 4 dup\n" +
923	" 5 invokespecial X$1() [10]\n" +
924	" 8 invokespecial Y(java.lang.Object) [12]\n" +
925	" 11 new java.lang.NullPointerException [15]\n" +
926	" 14 dup\n" +
927	" 15 invokespecial java.lang.NullPointerException() [17]\n" +
928	" 18 athrow\n" +
929	" Line numbers:\n" +
930	" [pc: 0, line: 14]\n" +
931	" [pc: 11, line: 10]\n" +
932	" Local variable table:\n" +
933	" [pc: 0, pc: 19] local: this index: 0 type: X\n";
934
935	try {
936	File f = new File(OUTPUT_DIR + File.separator + "X.class");
937	byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
938	ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
939	String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
940	int index = result.indexOf(expectedOutput);
941	if (index == -1 \|\| expectedOutput.length() == 0) {
942	System.out.println(Util.displayString(result, 3));
943	}
944	if (index == -1) {
945	assertEquals("Wrong contents", expectedOutput, result);
946	}
947	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
948	assertTrue(false);
949	} catch (IOException e) {
950	assertTrue(false);
951	}
952	}
953	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=155423 - variation
954	public void test031() {
955	this.runNegativeTest(
956	new String[] {
957	"X.java",
958	"class Y {\n" +
959	" Y(Object o) {\n" +
960	" }\n" +
961	"}\n" +
962	"\n" +
963	"public class X extends Y {\n" +
964	" final int blank;\n" +
965	" {\n" +
966	" if (true)\n" +
967	" throw new NullPointerException();\n" +
968	" }\n" +
969	"\n" +
970	" X() {\n" +
971	" super(new Object() {});\n" +
972	" }\n" +
973	"}\n", // =================
974	},
975	"----------\n" +
976	"1. ERROR in X.java (at line 13)\n" +
977	" X() {\n" +
978	" ^^^\n" +
979	"The blank final field blank may not have been initialized\n" +
980	"----------\n");
981	}
982	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=155423 - variation
983	public void test032() {
984	this.runNegativeTest(
985	new String[] {
986	"X.java",
987	"class Y {\n" +
988	" Y(int i) {\n" +
989	" }\n" +
990	"}\n" +
991	"\n" +
992	"public class X extends Y {\n" +
993	" final int blank;\n" +
994	" {\n" +
995	" if (true)\n" +
996	" throw new NullPointerException();\n" +
997	" }\n" +
998	"\n" +
999	" X() {\n" +
1000	" super(blank = 0);\n" +
1001	" }\n" +
1002	"}\n", // =================
1003	},
1004	"----------\n" +
1005	"1. ERROR in X.java (at line 14)\n" +
1006	" super(blank = 0);\n" +
1007	" ^^^^^\n" +
1008	"Cannot refer to an instance field blank while explicitly invoking a constructor\n" +
1009	"----------\n");
1010	}
1011	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=155423 - variation
1012	public void test033() {
1013	this.runConformTest(
1014	new String[] {
1015	"X.java",
1016	"class Y {\n" +
1017	" Y(int i) {\n" +
1018	" }\n" +
1019	"}\n" +
1020	"public class X extends Y {\n" +
1021	" final int blank;\n" +
1022	" {\n" +
1023	" if (true)\n" +
1024	" throw new NullPointerException();\n" +
1025	" }\n" +
1026	" X() {\n" +
1027	" super(0);\n" +
1028	" blank = 0;\n" +
1029	" }\n" +
1030	"}\n", // =================
1031	},
1032	"");
1033	}
780	public static Class testClass() {	1034	public static Class testClass() {
781	return FlowAnalysisTest.class;	1035	return FlowAnalysisTest.class;
782	}	1036	}




					method.analyseCode(
						this.scope, 
						staticInitializerContext,  
						staticFieldInfo.unconditionalInits().discardNonFieldInitializations().addInitializationsFrom(outerInfo));
				} else { // constructor
					((ConstructorDeclaration)method).analyseCode(this.scope, initializerContext, constructorInfo.copy(), flowInfo.reachMode());
					if (method.needFreeReturn) {
						method.needFreeReturn = (constructorInfo.tagBits & FlowInfo.UNREACHABLE) == 0;
					}
				}
			} else { // regular method
				method.analyseCode(this.scope, null, flowInfo.copy());




	public boolean isDefaultConstructor = false;
	public TypeParameter[] typeParameters;

public ConstructorDeclaration(CompilationResult compilationResult){
	super(compilationResult);
}

/** 
 * @see org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration#analyseCode(org.eclipse.jdt.internal.compiler.lookup.ClassScope, org.eclipse.jdt.internal.compiler.flow.InitializationFlowContext, org.eclipse.jdt.internal.compiler.flow.FlowInfo)
 * @deprecated use instead {@link #analyseCode(ClassScope, InitializationFlowContext, FlowInfo, int)}
 */
public void analyseCode(ClassScope classScope, InitializationFlowContext initializerFlowContext, FlowInfo flowInfo) {
	analyseCode(classScope, initializerFlowContext, flowInfo, FlowInfo.REACHABLE);
}

/**
 * The flowInfo corresponds to non-static field initialization infos. It may be unreachable (155423), but still the explicit constructor call must be
 * analysed as reachable, since it will be generated in the end.
 */
public void analyseCode(ClassScope classScope, InitializationFlowContext initializerFlowContext, FlowInfo flowInfo, int initialReachMode) {
	if (this.ignoreFurtherInvestigation)
		return;

	int nonStaticFieldInfoReachMode = flowInfo.reachMode();
	flowInfo.setReachMode(initialReachMode);
	
	if (this.binding != null && !this.binding.isUsed() && (this.binding.isPrivate() || (this.binding.declaringClass.tagBits & (TagBits.IsAnonymousType|TagBits.IsLocalType)) == TagBits.IsLocalType)) {
		if (!classScope.referenceCompilationUnit().compilationResult.hasSyntaxError) {
			this.scope.problemReporter().unusedPrivateConstructor(this);
		FlowInfo flowInfo) {

		if (ignoreFurtherInvestigation)
			return;

		if (this.binding != null && !this.binding.isUsed() && (this.binding.isPrivate() || (this.binding.declaringClass.tagBits & (TagBits.IsAnonymousType|TagBits.IsLocalType)) == TagBits.IsLocalType)) {
			if (!classScope.referenceCompilationUnit().compilationResult.hasSyntaxError) {
				scope.problemReporter().unusedPrivateConstructor(this);
			}
		}
	}
		
	// check constructor recursion, once all constructor got resolved
	if (isRecursive(null /*lazy initialized visited list*/)) {				
		this.scope.problemReporter().recursiveConstructorInvocation(this.constructorCall);
	}
		
	try {
		ExceptionHandlingFlowContext constructorContext =
			new ExceptionHandlingFlowContext(
				initializerFlowContext.parent,
				this,
				this.binding.thrownExceptions,
				this.scope,
				FlowInfo.DEAD_END);
		initializerFlowContext.checkInitializerExceptions(
			this.scope,
			constructorContext,
			flowInfo);

		// anonymous constructor can gain extra thrown exceptions from unhandled ones
		if (this.binding.declaringClass.isAnonymousType()) {
			ArrayList computedExceptions = constructorContext.extendedExceptions;
			if (computedExceptions != null){
				int size;
				if ((size = computedExceptions.size()) > 0){
					ReferenceBinding[] actuallyThrownExceptions;
					computedExceptions.toArray(actuallyThrownExceptions = new ReferenceBinding[size]);
					this.binding.thrownExceptions = actuallyThrownExceptions;
				}
			}
		}
		
		// tag parameters as being set
		if (this.arguments != null) {
			for (int i = 0, count = this.arguments.length; i < count; i++) {
				flowInfo.markAsDefinitelyAssigned(this.arguments[i].binding);
			}
		}
		
		// propagate to constructor call
		if (this.constructorCall != null) {
			// if calling 'this(...)', then flag all non-static fields as definitely
			// set since they are supposed to be set inside other local constructor
			if (this.constructorCall.accessMode == ExplicitConstructorCall.This) {
				FieldBinding[] fields = this.binding.declaringClass.fields();
				for (int i = 0, count = fields.length; i < count; i++) {
					FieldBinding field;
					if (!(field = fields[i]).isStatic()) {
						flowInfo.markAsDefinitelyAssigned(field);
					}
				}
				flowInfo = constructorCall.analyseCode(scope, constructorContext, flowInfo);
			}
			flowInfo = this.constructorCall.analyseCode(this.scope, constructorContext, flowInfo);
		}
		
		// reuse the reachMode from non static field info
		flowInfo.setReachMode(nonStaticFieldInfoReachMode);

		// propagate to statements
		if (this.statements != null) {
			boolean didAlreadyComplain = false;
			for (int i = 0, count = this.statements.length; i < count; i++) {
				Statement stat = this.statements[i];
				if (!stat.complainIfUnreachable(flowInfo, this.scope, didAlreadyComplain)) {
					flowInfo = stat.analyseCode(this.scope, constructorContext, flowInfo);
				} else {
					didAlreadyComplain = true;
				}
			}
		}
		// check for missing returning path
		this.needFreeReturn = (flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0;

		// reuse the initial reach mode for diagnosing missing blank finals
		flowInfo.setReachMode(initialReachMode);		

		// check missing blank final field initializations
		if ((this.constructorCall != null)
			&& (this.constructorCall.accessMode != ExplicitConstructorCall.This)) {
			flowInfo = flowInfo.mergedWith(constructorContext.initsOnReturn);
			FieldBinding[] fields = this.binding.declaringClass.fields();
			for (int i = 0, count = fields.length; i < count; i++) {
				FieldBinding field;
				if ((!(field = fields[i]).isStatic())
					&& field.isFinal()
					&& (!flowInfo.isDefinitelyAssigned(fields[i]))) {
					this.scope.problemReporter().uninitializedBlankFinalField(
						field,
						this.isDefaultConstructor ? (ASTNode) this.scope.referenceType() : this);
				}
			}
			// check unreachable catch blocks
			constructorContext.complainIfUnusedExceptionHandlers(this);
		} catch (AbortMethod e) {
			this.ignoreFurtherInvestigation = true;
		}
		// check unreachable catch blocks
		constructorContext.complainIfUnusedExceptionHandlers(this);
	} catch (AbortMethod e) {
		this.ignoreFurtherInvestigation = true;
	}
}

/**
 * Bytecode generation for a constructor
 *
 * @param classScope org.eclipse.jdt.internal.compiler.lookup.ClassScope
 * @param classFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
 */
public void generateCode(ClassScope classScope, ClassFile classFile) {
	int problemResetPC = 0;
	if (this.ignoreFurtherInvestigation) {
		if (this.binding == null)
			return; // Handle methods with invalid signature or duplicates
		int problemsLength;
		CategorizedProblem[] problems =
			this.scope.referenceCompilationUnit().compilationResult.getProblems();
		CategorizedProblem[] problemsCopy = new CategorizedProblem[problemsLength = problems.length];
		System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
		classFile.addProblemConstructor(this, this.binding, problemsCopy);
		return;
	}
	try {
		problemResetPC = classFile.contentsOffset;
		this.internalGenerateCode(classScope, classFile);
	} catch (AbortMethod e) {
		if (e.compilationResult == CodeStream.RESTART_IN_WIDE_MODE) {
			// a branch target required a goto_w, restart code gen in wide mode.
			try {
				classFile.contentsOffset = problemResetPC;
				classFile.methodCount--;
				classFile.codeStream.wideMode = true; // request wide mode 
				this.internalGenerateCode(classScope, classFile); // restart method generation
			} catch (AbortMethod e2) {
				} catch (AbortMethod e2) {
					int problemsLength;
					CategorizedProblem[] problems =
						scope.referenceCompilationUnit().compilationResult.getAllProblems();
					CategorizedProblem[] problemsCopy = new CategorizedProblem[problemsLength = problems.length];
					System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
					classFile.addProblemConstructor(this, binding, problemsCopy, problemResetPC);
				}
			} else {
				int problemsLength;
				CategorizedProblem[] problems =
					this.scope.referenceCompilationUnit().compilationResult.getAllProblems();
				CategorizedProblem[] problemsCopy = new CategorizedProblem[problemsLength = problems.length];
				System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
				classFile.addProblemConstructor(this, this.binding, problemsCopy, problemResetPC);
			}
		} else {
			int problemsLength;
			CategorizedProblem[] problems =
				this.scope.referenceCompilationUnit().compilationResult.getAllProblems();
			CategorizedProblem[] problemsCopy = new CategorizedProblem[problemsLength = problems.length];
			System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
			classFile.addProblemConstructor(this, this.binding, problemsCopy, problemResetPC);
		}
	}
}

public void generateSyntheticFieldInitializationsIfNecessary(MethodScope methodScope, CodeStream codeStream, ReferenceBinding declaringClass) {
	if (!declaringClass.isNestedType()) return;
	
	NestedTypeBinding nestedType = (NestedTypeBinding) declaringClass;
			
		if (!declaringClass.isNestedType()) return;
		
		NestedTypeBinding nestedType = (NestedTypeBinding) declaringClass;

	SyntheticArgumentBinding[] syntheticArgs = nestedType.syntheticEnclosingInstances();
	for (int i = 0, max = syntheticArgs == null ? 0 : syntheticArgs.length; i < max; i++) {
		SyntheticArgumentBinding syntheticArg;
		if ((syntheticArg = syntheticArgs[i]).matchingField != null) {
			codeStream.aload_0();
			codeStream.load(syntheticArg);
			codeStream.putfield(syntheticArg.matchingField);
		}
	}
	syntheticArgs = nestedType.syntheticOuterLocalVariables();
	for (int i = 0, max = syntheticArgs == null ? 0 : syntheticArgs.length; i < max; i++) {
		SyntheticArgumentBinding syntheticArg;
		if ((syntheticArg = syntheticArgs[i]).matchingField != null) {
			codeStream.aload_0();
			codeStream.load(syntheticArg);
			codeStream.putfield(syntheticArg.matchingField);
			}
		}
	}
}

private void internalGenerateCode(ClassScope classScope, ClassFile classFile) {
	classFile.generateMethodInfoHeader(this.binding);
	int methodAttributeOffset = classFile.contentsOffset;
	int attributeNumber = classFile.generateMethodInfoAttribute(this.binding);
	if ((!this.binding.isNative()) && (!this.binding.isAbstract())) {
		
		TypeDeclaration declaringType = classScope.referenceContext;
		int codeAttributeOffset = classFile.contentsOffset;
		classFile.generateCodeAttributeHeader();
		CodeStream codeStream = classFile.codeStream;
		codeStream.reset(this, classFile);

		// initialize local positions - including initializer scope.
		ReferenceBinding declaringClass = this.binding.declaringClass;

		int enumOffset = declaringClass.isEnum() ? 2 : 0; // String name, int ordinal
		int argSlotSize = 1 + enumOffset; // this==aload0

		if (declaringClass.isNestedType()){
			NestedTypeBinding nestedType = (NestedTypeBinding) declaringClass;
			this.scope.extraSyntheticArguments = nestedType.syntheticOuterLocalVariables();
			this.scope.computeLocalVariablePositions(// consider synthetic arguments if any
				nestedType.enclosingInstancesSlotSize + 1 + enumOffset,
				codeStream);
			argSlotSize += nestedType.enclosingInstancesSlotSize;
			argSlotSize += nestedType.outerLocalVariablesSlotSize;
		} else {
			this.scope.computeLocalVariablePositions(1 + enumOffset,  codeStream);
		}
			
		if (this.arguments != null) {
			for (int i = 0, max = this.arguments.length; i < max; i++) {
				// arguments initialization for local variable debug attributes
				LocalVariableBinding argBinding;
				codeStream.addVisibleLocalVariable(argBinding = this.arguments[i].binding);
				argBinding.recordInitializationStartPC(0);
				TypeBinding argType;
				if ((argType = argBinding.type) == TypeBinding.LONG || (argType == TypeBinding.DOUBLE)) {
					argSlotSize += 2;
				} else {
					argSlotSize++;

			if (declaringClass.isNestedType()){
				NestedTypeBinding nestedType = (NestedTypeBinding) declaringClass;
				this.scope.extraSyntheticArguments = nestedType.syntheticOuterLocalVariables();
				scope.computeLocalVariablePositions(// consider synthetic arguments if any
					nestedType.enclosingInstancesSlotSize + 1 + enumOffset,
					codeStream);
				argSlotSize += nestedType.enclosingInstancesSlotSize;
				argSlotSize += nestedType.outerLocalVariablesSlotSize;
			} else {
				scope.computeLocalVariablePositions(1 + enumOffset,  codeStream);
			}
				
			if (arguments != null) {
				for (int i = 0, max = arguments.length; i < max; i++) {
					// arguments initialization for local variable debug attributes
					LocalVariableBinding argBinding;
					codeStream.addVisibleLocalVariable(argBinding = arguments[i].binding);
					argBinding.recordInitializationStartPC(0);
					TypeBinding argType;
					if ((argType = argBinding.type) == TypeBinding.LONG || (argType == TypeBinding.DOUBLE)) {
						argSlotSize += 2;
					} else {
						argSlotSize++;
					}
				}
			}
		}
		
		MethodScope initializerScope = declaringType.initializerScope;
		initializerScope.computeLocalVariablePositions(argSlotSize, codeStream); // offset by the argument size (since not linked to method scope)

		boolean needFieldInitializations = this.constructorCall == null || this.constructorCall.accessMode != ExplicitConstructorCall.This;

		// post 1.4 target level, synthetic initializations occur prior to explicit constructor call
		boolean preInitSyntheticFields = this.scope.compilerOptions().targetJDK >= ClassFileConstants.JDK1_4;

		if (needFieldInitializations && preInitSyntheticFields){
			generateSyntheticFieldInitializationsIfNecessary(this.scope, codeStream, declaringClass);
		}			
		// generate constructor call
		if (this.constructorCall != null) {
			this.constructorCall.generateCode(this.scope, codeStream);
		}
		// generate field initialization - only if not invoking another constructor call of the same class
		if (needFieldInitializations) {
			if (!preInitSyntheticFields){
				generateSyntheticFieldInitializationsIfNecessary(this.scope, codeStream, declaringClass);
			}
			// generate user field initialization
			if (declaringType.fields != null) {
				for (int i = 0, max = declaringType.fields.length; i < max; i++) {
					FieldDeclaration fieldDecl;
					if (!(fieldDecl = declaringType.fields[i]).isStatic()) {
						fieldDecl.generateCode(initializerScope, codeStream);
						}
					}
				}
			}
			// generate statements
			if (statements != null) {
				for (int i = 0, max = statements.length; i < max; i++) {
					statements[i].generateCode(scope, codeStream);
				}
			}
			if (this.needFreeReturn) {
				codeStream.return_();
			}
			// local variable attributes
			codeStream.exitUserScope(scope);
			codeStream.recordPositionsFrom(0, this.bodyEnd);
			classFile.completeCodeAttribute(codeAttributeOffset);
			attributeNumber++;
		}
		classFile.completeMethodInfo(methodAttributeOffset, attributeNumber);

		// if a problem got reported during code gen, then trigger problem method creation
		if (ignoreFurtherInvestigation) {
			throw new AbortMethod(scope.referenceCompilationUnit().compilationResult, null);
		}
		// generate statements
		if (this.statements != null) {
			for (int i = 0, max = this.statements.length; i < max; i++) {
				this.statements[i].generateCode(this.scope, codeStream);
			}
		}
		if (this.needFreeReturn) {
			codeStream.return_();
		}
		// local variable attributes
		codeStream.exitUserScope(this.scope);
		codeStream.recordPositionsFrom(0, this.bodyEnd);
		classFile.completeCodeAttribute(codeAttributeOffset);
		attributeNumber++;
	}
	classFile.completeMethodInfo(methodAttributeOffset, attributeNumber);

	// if a problem got reported during code gen, then trigger problem method creation
	if (this.ignoreFurtherInvestigation) {
		throw new AbortMethod(this.scope.referenceCompilationUnit().compilationResult, null);
	}
}

public boolean isConstructor() {
	return true;
}

public boolean isDefaultConstructor() {
	return this.isDefaultConstructor;
}

public boolean isInitializationMethod() {
	return true;
}

/*
 * Returns true if the constructor is directly involved in a cycle.
 * Given most constructors aren't, we only allocate the visited list
 * lazily.
 */
public boolean isRecursive(ArrayList visited) {
	if (this.binding == null
			|| this.constructorCall == null
			|| this.constructorCall.binding == null
			|| this.constructorCall.isSuperAccess()
			|| !this.constructorCall.binding.isValidBinding()) {
		return false;
	}
	
	ConstructorDeclaration targetConstructor = 
		((ConstructorDeclaration)this.scope.referenceType().declarationOf(this.constructorCall.binding.original()));
	if (this == targetConstructor) return true; // direct case

	if (visited == null) { // lazy allocation
		visited = new ArrayList(1);
	} else {
		int index = visited.indexOf(this);
		if (index >= 0) return index == 0; // only blame if directly part of the cycle
	}
	visited.add(this);

	return targetConstructor.isRecursive(visited);
}
	 * Given most constructors aren't, we only allocate the visited list
	 * lazily.
	 */
	public boolean isRecursive(ArrayList visited) {

public void parseStatements(Parser parser, CompilationUnitDeclaration unit) {
	//fill up the constructor body with its statements
	if (this.ignoreFurtherInvestigation)
		return;
	if (this.isDefaultConstructor && this.constructorCall == null){
		this.constructorCall = SuperReference.implicitSuperConstructorCall();
		this.constructorCall.sourceStart = this.sourceStart;
		this.constructorCall.sourceEnd = this.sourceEnd; 
		return;
	}
	parser.parse(this, unit);

}
			visited = new ArrayList(1);
		} else {
			int index = visited.indexOf(this);
			if (index >= 0) return index == 0; // only blame if directly part of the cycle
		}
		visited.add(this);

public StringBuffer printBody(int indent, StringBuffer output) {
	output.append(" {"); //$NON-NLS-1$
	if (this.constructorCall != null) {
		output.append('\n');
		this.constructorCall.printStatement(indent, output);
	}
	if (this.statements != null) {
		for (int i = 0; i < this.statements.length; i++) {
			output.append('\n');
			this.statements[i].printStatement(indent, output);
		if (ignoreFurtherInvestigation)
			return;
		if (isDefaultConstructor && this.constructorCall == null){
			this.constructorCall = SuperReference.implicitSuperConstructorCall();
			this.constructorCall.sourceStart = this.sourceStart;
			this.constructorCall.sourceEnd = this.sourceEnd; 
			return;
		}
	}
	output.append('\n');
	printIndent(indent == 0 ? 0 : indent - 1, output).append('}');
	return output;
}

public void resolveJavadoc() {
	if (this.binding == null || this.javadoc != null) {
		super.resolveJavadoc();
	} else if (!this.isDefaultConstructor) {
		this.scope.problemReporter().javadocMissing(this.sourceStart, this.sourceEnd, this.binding.modifiers);
	}
}

/*
 * Type checking for constructor, just another method, except for special check
 * for recursive constructor invocations.
 */
public void resolveStatements() {
	if (!CharOperation.equals(this.scope.enclosingSourceType().sourceName, this.selector)){
		this.scope.problemReporter().missingReturnType(this);
	}

	if (this.typeParameters != null) {
		for (int i = 0, length = this.typeParameters.length; i < length; i++) {
			this.typeParameters[i].resolve(this.scope);
			constructorCall.printStatement(indent, output);
		}
		if (statements != null) {
			for (int i = 0; i < statements.length; i++) {
				output.append('\n');
				statements[i].printStatement(indent, output);
			}
		}
		output.append('\n');
		printIndent(indent == 0 ? 0 : indent - 1, output).append('}');
		return output;
	}
	
	// if null ==> an error has occurs at parsing time ....
	if (this.constructorCall != null) {
		// e.g. using super() in java.lang.Object
		if (this.binding != null
			&& this.binding.declaringClass.id == TypeIds.T_JavaLangObject
			&& this.constructorCall.accessMode != ExplicitConstructorCall.This) {
				if (this.constructorCall.accessMode == ExplicitConstructorCall.Super) {
					this.scope.problemReporter().cannotUseSuperInJavaLangObject(this.constructorCall);
				}
				this.constructorCall = null;
		} else {
			this.constructorCall.resolve(this.scope);
		}
	}
	if ((this.modifiers & ExtraCompilerModifiers.AccSemicolonBody) != 0) {
		this.scope.problemReporter().methodNeedBody(this);		
	}
	super.resolveStatements();
}

public void traverse(ASTVisitor visitor,	ClassScope classScope) {
	if (visitor.visit(this, classScope)) {
		if (this.annotations != null) {
			int annotationsLength = this.annotations.length;
			for (int i = 0; i < annotationsLength; i++)
				this.annotations[i].traverse(visitor, this.scope);
		if (!CharOperation.equals(this.scope.enclosingSourceType().sourceName, selector)){
			this.scope.problemReporter().missingReturnType(this);
		}

		if (this.typeParameters != null) {
			int typeParametersLength = this.typeParameters.length;
			for (int i = 0; i < typeParametersLength; i++) {
				this.typeParameters[i].traverse(visitor, this.scope);
			}
		}			
		if (this.arguments != null) {
			int argumentLength = this.arguments.length;
			for (int i = 0; i < argumentLength; i++)
				this.arguments[i].traverse(visitor, this.scope);
		}
		if (this.thrownExceptions != null) {
			int thrownExceptionsLength = this.thrownExceptions.length;
			for (int i = 0; i < thrownExceptionsLength; i++)
				this.thrownExceptions[i].traverse(visitor, this.scope);
		}
		if (this.constructorCall != null)
			this.constructorCall.traverse(visitor, this.scope);
		if (this.statements != null) {
			int statementsLength = this.statements.length;
			for (int i = 0; i < statementsLength; i++)
				this.statements[i].traverse(visitor, this.scope);
		}
		super.resolveStatements();
	}
	visitor.endVisit(this, classScope);
}
public TypeParameter[] typeParameters() {
    return this.typeParameters;
}		
		
		if (visitor.visit(this, classScope)) {
			if (this.annotations != null) {
				int annotationsLength = this.annotations.length;
				for (int i = 0; i < annotationsLength; i++)
					this.annotations[i].traverse(visitor, scope);
			}
			if (this.typeParameters != null) {
				int typeParametersLength = this.typeParameters.length;
				for (int i = 0; i < typeParametersLength; i++) {
					this.typeParameters[i].traverse(visitor, scope);
				}
			}			
			if (arguments != null) {
				int argumentLength = arguments.length;
				for (int i = 0; i < argumentLength; i++)
					arguments[i].traverse(visitor, scope);
			}
			if (thrownExceptions != null) {
				int thrownExceptionsLength = thrownExceptions.length;
				for (int i = 0; i < thrownExceptionsLength; i++)
					thrownExceptions[i].traverse(visitor, scope);
			}
			if (constructorCall != null)
				constructorCall.traverse(visitor, scope);
			if (statements != null) {
				int statementsLength = statements.length;
				for (int i = 0; i < statementsLength; i++)
					statements[i].traverse(visitor, scope);
			}
		}
		visitor.endVisit(this, classScope);
	}
	public TypeParameter[] typeParameters() {
	    return this.typeParameters;
	}		
}

Return to bug 155423

Lines 665-676 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java (-5 / +2 lines)
665	method.analyseCode(	665	method.analyseCode(
666	this.scope,	666	this.scope,
667	staticInitializerContext,	667	staticInitializerContext,
668	staticFieldInfo.unconditionalInits().discardNonFieldInitializations().addInitializationsFrom(outerInfo).setReachMode(flowInfo.reachMode())); // reset reach mode in case initializers did abrupt completely	668	staticFieldInfo.unconditionalInits().discardNonFieldInitializations().addInitializationsFrom(outerInfo));
669	} else { // constructor	669	} else { // constructor
670	method.analyseCode(this.scope, initializerContext, constructorInfo.copy().setReachMode(flowInfo.reachMode())); // reset reach mode in case initializers did abrupt completely	670	((ConstructorDeclaration)method).analyseCode(this.scope, initializerContext, constructorInfo.copy(), flowInfo.reachMode());
671	if (method.needFreeReturn) {
672	method.needFreeReturn = (constructorInfo.tagBits & FlowInfo.UNREACHABLE) == 0;
673	}
674	}	671	}
675	} else { // regular method	672	} else { // regular method
676	method.analyseCode(this.scope, null, flowInfo.copy());	673	method.analyseCode(this.scope, null, flowInfo.copy());