Attachment #62086 for bug #179477




			for (int i = 0, length = this.expressions.length; i < length; i++) {
				Expression expression = this.expressions[i];
				expression.setExpectedType(elementType);
				TypeBinding expressionType = expression instanceof ArrayInitializer
						? expression.resolveTypeExpecting(scope, elementType)
						: expression.resolveType(scope);
				if (expressionType == null)
					continue;

				// Compile-time conversion required?
				if (elementType != expressionType) // must call before computeConversion() and typeMismatchError()
					scope.compilationUnitScope().recordTypeConversion(elementType, expressionType);

				if ((expression.isConstantValueOfTypeAssignableToType(expressionType, elementType)
						|| (elementType.isBaseType() && BaseTypeBinding.isWidening(elementType.id, expressionType.id)))
						|| expressionType.isCompatibleWith(elementType)) {
					expression.computeConversion(scope, elementType, expressionType);
				} else if (scope.isBoxingCompatibleWith(expressionType, elementType) 
									|| (expressionType.isBaseType()  // narrowing then boxing ?
											&& scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5 // autoboxing
											&& !elementType.isBaseType()
											&& expression.isConstantValueOfTypeAssignableToType(expressionType, scope.environment().computeBoxingType(elementType)))) {
					expression.computeConversion(scope, elementType, expressionType);
				} else {
					scope.problemReporter().typeMismatchError(expressionType, elementType, expression);
					return null;
				} 				
			}
			return this.binding;




	"        [pc: 0, pc: 15] local: this index: 0 type: X\n" + 
	"        [pc: 13, pc: 15] local: all index: 1 type: java.lang.Object[][]\n";

	try {
		File f = new File(OUTPUT_DIR + File.separator + "X.class");
		byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
		ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
		String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
		int index = result.indexOf(expectedOutput);
		if (index == -1 || expectedOutput.length() == 0) {
			System.out.println(Util.displayString(result, 3));
		}
		if (index == -1) {
			assertEquals("Wrong contents", expectedOutput, result);
		}
	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
		assertTrue(false);
	} catch (IOException e) {
		assertTrue(false);
	}		
}
//check resolution of faulty initializer
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=179477
public void test013() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" + 
			"    String[] m(String arg) {\n" + 
			"        System.out.println(argument + argument);\n" + 
			"        return new String[] { argument + argument, argument/*no problem*/ };\n" + 
			"    }\n" + 
			"}", // =================
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	System.out.println(argument + argument);\n" + 
		"	                   ^^^^^^^^\n" + 
		"argument cannot be resolved\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 3)\n" + 
		"	System.out.println(argument + argument);\n" + 
		"	                              ^^^^^^^^\n" + 
		"argument cannot be resolved\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 4)\n" + 
		"	return new String[] { argument + argument, argument/*no problem*/ };\n" + 
		"	                      ^^^^^^^^\n" + 
		"argument cannot be resolved\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 4)\n" + 
		"	return new String[] { argument + argument, argument/*no problem*/ };\n" + 
		"	                                 ^^^^^^^^\n" + 
		"argument cannot be resolved\n" + 
		"----------\n" + 
		"5. ERROR in X.java (at line 4)\n" + 
		"	return new String[] { argument + argument, argument/*no problem*/ };\n" + 
		"	                                           ^^^^^^^^\n" + 
		"argument cannot be resolved\n" + 
		"----------\n");
}
}

Return to bug 179477

Lines 357-378 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/ArrayTest.java (-17 / +57 lines)
357	" [pc: 0, pc: 15] local: this index: 0 type: X\n" +	357	" [pc: 0, pc: 15] local: this index: 0 type: X\n" +
358	" [pc: 13, pc: 15] local: all index: 1 type: java.lang.Object[][]\n";	358	" [pc: 13, pc: 15] local: all index: 1 type: java.lang.Object[][]\n";
359		359
360	try {	360	try {
361	File f = new File(OUTPUT_DIR + File.separator + "X.class");	361	File f = new File(OUTPUT_DIR + File.separator + "X.class");
362	byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);	362	byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(f);
363	ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();	363	ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
364	String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);	364	String result = disassembler.disassemble(classFileBytes, "\n", ClassFileBytesDisassembler.DETAILED);
365	int index = result.indexOf(expectedOutput);	365	int index = result.indexOf(expectedOutput);
366	if (index == -1 \|\| expectedOutput.length() == 0) {	366	if (index == -1 \|\| expectedOutput.length() == 0) {
367	System.out.println(Util.displayString(result, 3));	367	System.out.println(Util.displayString(result, 3));
368	}	368	}
369	if (index == -1) {	369	if (index == -1) {
370	assertEquals("Wrong contents", expectedOutput, result);	370	assertEquals("Wrong contents", expectedOutput, result);
371	}	371	}
372	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {	372	} catch (org.eclipse.jdt.core.util.ClassFormatException e) {
373	assertTrue(false);	373	assertTrue(false);
374	} catch (IOException e) {	374	} catch (IOException e) {
375	assertTrue(false);	375	assertTrue(false);
376	}	376	}
		377	}
		378	//check resolution of faulty initializer
		379	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=179477
		380	public void test013() {
		381	this.runNegativeTest(
		382	new String[] {
		383	"X.java",
		384	"public class X {\n" +
		385	" String[] m(String arg) {\n" +
		386	" System.out.println(argument + argument);\n" +
		387	" return new String[] { argument + argument, argument/no problem/ };\n" +
		388	" }\n" +
		389	"}", // =================
		390	},
		391	"----------\n" +
		392	"1. ERROR in X.java (at line 3)\n" +
		393	" System.out.println(argument + argument);\n" +
		394	" ^^^^^^^^\n" +
		395	"argument cannot be resolved\n" +
		396	"----------\n" +
		397	"2. ERROR in X.java (at line 3)\n" +
		398	" System.out.println(argument + argument);\n" +
		399	" ^^^^^^^^\n" +
		400	"argument cannot be resolved\n" +
		401	"----------\n" +
		402	"3. ERROR in X.java (at line 4)\n" +
		403	" return new String[] { argument + argument, argument/no problem/ };\n" +
		404	" ^^^^^^^^\n" +
		405	"argument cannot be resolved\n" +
		406	"----------\n" +
		407	"4. ERROR in X.java (at line 4)\n" +
		408	" return new String[] { argument + argument, argument/no problem/ };\n" +
		409	" ^^^^^^^^\n" +
		410	"argument cannot be resolved\n" +
		411	"----------\n" +
		412	"5. ERROR in X.java (at line 4)\n" +
		413	" return new String[] { argument + argument, argument/no problem/ };\n" +
		414	" ^^^^^^^^\n" +
		415	"argument cannot be resolved\n" +
		416	"----------\n");
377	}	417	}
378	}	418	}

Lines 155-183 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ArrayInitializer.java (-15 / +14 lines)
155	for (int i = 0, length = this.expressions.length; i < length; i++) {	155	for (int i = 0, length = this.expressions.length; i < length; i++) {
156	Expression expression = this.expressions[i];	156	Expression expression = this.expressions[i];
157	expression.setExpectedType(elementType);	157	expression.setExpectedType(elementType);
158	TypeBinding exprType = expression instanceof ArrayInitializer	158	TypeBinding expressionType = expression instanceof ArrayInitializer
159	? expression.resolveTypeExpecting(scope, elementType)	159	? expression.resolveTypeExpecting(scope, elementType)
160	: expression.resolveType(scope);	160	: expression.resolveType(scope);
161	if (exprType == null)	161	if (expressionType == null)
162	return null;	162	continue;
163		163
164	// Compile-time conversion required?	164	// Compile-time conversion required?
165	if (elementType != exprType) // must call before computeConversion() and typeMismatchError()	165	if (elementType != expressionType) // must call before computeConversion() and typeMismatchError()
166	scope.compilationUnitScope().recordTypeConversion(elementType, exprType);	166	scope.compilationUnitScope().recordTypeConversion(elementType, expressionType);
167		167
168	if ((expression.isConstantValueOfTypeAssignableToType(exprType, elementType)	168	if ((expression.isConstantValueOfTypeAssignableToType(expressionType, elementType)
169	\|\| (elementType.isBaseType() && BaseTypeBinding.isWidening(elementType.id, exprType.id)))	169	\|\| (elementType.isBaseType() && BaseTypeBinding.isWidening(elementType.id, expressionType.id)))
170	\|\| exprType.isCompatibleWith(elementType)) {	170	\|\| expressionType.isCompatibleWith(elementType)) {
171	expression.computeConversion(scope, elementType, exprType);	171	expression.computeConversion(scope, elementType, expressionType);
172	} else if (scope.isBoxingCompatibleWith(exprType, elementType)	172	} else if (scope.isBoxingCompatibleWith(expressionType, elementType)
173	\|\| (exprType.isBaseType() // narrowing then boxing ?	173	\|\| (expressionType.isBaseType() // narrowing then boxing ?
174	&& scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5 // autoboxing	174	&& scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5 // autoboxing
175	&& !elementType.isBaseType()	175	&& !elementType.isBaseType()
176	&& expression.isConstantValueOfTypeAssignableToType(exprType, scope.environment().computeBoxingType(elementType)))) {	176	&& expression.isConstantValueOfTypeAssignableToType(expressionType, scope.environment().computeBoxingType(elementType)))) {
177	expression.computeConversion(scope, elementType, exprType);	177	expression.computeConversion(scope, elementType, expressionType);
178	} else {	178	} else {
179	scope.problemReporter().typeMismatchError(exprType, elementType, expression);	179	scope.problemReporter().typeMismatchError(expressionType, elementType, expression);
180	return null;
181	}	180	}
182	}	181	}
183	return this.binding;	182	return this.binding;