Attachment #191946 for bug #339478

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 29-35 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (-2 / +15 lines)
29	public TypeReference[] typeArguments;	29	public TypeReference[] typeArguments;
30	public TypeBinding[] genericTypeArguments;	30	public TypeBinding[] genericTypeArguments;
31	public FieldDeclaration enumConstant; // for enum constant initializations	31	public FieldDeclaration enumConstant; // for enum constant initializations
32		32	protected TypeBinding expectedType;
		33
33	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	34	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
34	// check captured variables are initialized in current context (26134)	35	// check captured variables are initialized in current context (26134)
35	checkCapturedLocalInitializationIfNecessary((ReferenceBinding)this.binding.declaringClass.erasure(), currentScope, flowInfo);	36	checkCapturedLocalInitializationIfNecessary((ReferenceBinding)this.binding.declaringClass.erasure(), currentScope, flowInfo);
Lines 255-261 Link Here
255	// initialization of an enum constant	256	// initialization of an enum constant
256	this.resolvedType = scope.enclosingReceiverType();	257	this.resolvedType = scope.enclosingReceiverType();
257	} else {	258	} else {
258	this.resolvedType = this.type.resolveType(scope, true /* check bounds*/);	259	TypeBinding inferredArguments[] = null;
		260	if ((scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_7) && (this.type.bits & ASTNode.IsDiamond) != 0) {
		261	if (this.expectedType != null && this.expectedType.isParameterizedTypeWithActualArguments())
		262	inferredArguments = ((ParameterizedTypeBinding)this.expectedType).arguments;
		263	}
		264	this.resolvedType = this.type.resolveType(scope, true /* check bounds*/, inferredArguments);
259	checkParameterizedAllocation: {	265	checkParameterizedAllocation: {
260	if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()	266	if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()
261	ReferenceBinding currentType = (ReferenceBinding)this.resolvedType;	267	ReferenceBinding currentType = (ReferenceBinding)this.resolvedType;
Lines 409-412 Link Here
409	}	415	}
410	visitor.endVisit(this, scope);	416	visitor.endVisit(this, scope);
411	}	417	}
		418	/**
		419	* @see org.eclipse.jdt.internal.compiler.ast.Expression#setExpectedType(org.eclipse.jdt.internal.compiler.lookup.TypeBinding)
		420	*/
		421	public void setExpectedType(TypeBinding expectedType) {
		422	this.expectedType = expectedType;
		423	}
		424
412	}	425	}




					this.initialization.computeConversion(initializationScope, fieldType, initializationType);
				}
			} else if ((initializationType = this.initialization.resolveType(initializationScope)) != null) {
				boolean isDiamond = false;
				if (this.initialization instanceof AllocationExpression) {	
					AllocationExpression allocationExpression = (AllocationExpression) this.initialization;
					if (initializationScope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_7 
							&& allocationExpression.type != null
							&& (allocationExpression.type.bits & ASTNode.IsDiamond) != 0) {
						isDiamond = true;
					}
				}
				if (fieldType != initializationType) // must call before computeConversion() and typeMismatchError()
					initializationScope.compilationUnitScope().recordTypeConversion(fieldType, initializationType);
				if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, fieldType)
						|| initializationType.isCompatibleWith(fieldType, isDiamond)) {
					this.initialization.computeConversion(initializationScope, fieldType, initializationType);
					if (initializationType.needsUncheckedConversion(fieldType)) {
						    initializationScope.problemReporter().unsafeTypeConversion(this.initialization, initializationType, fieldType);

Lines 157-163 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java (-2 / +11 lines)
157	}	157	}
158		158
159	public void resolve(BlockScope scope) {	159	public void resolve(BlockScope scope) {
160		160	boolean isCompliant17 = scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_7;
161	// create a binding and add it to the scope	161	// create a binding and add it to the scope
162	TypeBinding variableType = this.type.resolveType(scope, true /* check bounds*/);	162	TypeBinding variableType = this.type.resolveType(scope, true /* check bounds*/);
163		163
Lines 171-176 Link Here
171	scope.problemReporter().variableTypeCannotBeVoidArray(this);	171	scope.problemReporter().variableTypeCannotBeVoidArray(this);
172	return;	172	return;
173	}	173	}
		174	if (isCompliant17 && variableType.isParameterizedType() && (this.type.bits & ASTNode.IsDiamond) != 0) {
		175	scope.problemReporter().incorrectArityForParameterizedType(this.type, variableType.original(), ((ParameterizedTypeBinding)variableType).arguments);
		176	return;
		177	}
174	}	178	}
175		179
176	Binding existingVariable = scope.getBinding(this.name, Binding.VARIABLE, this, false /do not resolve hidden field/);	180	Binding existingVariable = scope.getBinding(this.name, Binding.VARIABLE, this, false /do not resolve hidden field/);
Lines 207-218 Link Here
207	}	211	}
208	} else {	212	} else {
209	this.initialization.setExpectedType(variableType);	213	this.initialization.setExpectedType(variableType);
		214	boolean isDiamond = false;
210	TypeBinding initializationType = this.initialization.resolveType(scope);	215	TypeBinding initializationType = this.initialization.resolveType(scope);
		216	if (this.initialization instanceof AllocationExpression) {
		217	if (isCompliant17 && (((AllocationExpression) this.initialization).type.bits & ASTNode.IsDiamond) != 0)
		218	isDiamond = true;
		219	}
211	if (initializationType != null) {	220	if (initializationType != null) {
212	if (variableType != initializationType) // must call before computeConversion() and typeMismatchError()	221	if (variableType != initializationType) // must call before computeConversion() and typeMismatchError()
213	scope.compilationUnitScope().recordTypeConversion(variableType, initializationType);	222	scope.compilationUnitScope().recordTypeConversion(variableType, initializationType);
214	if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, variableType)	223	if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, variableType)
215	\|\| initializationType.isCompatibleWith(variableType)) {	224	\|\| initializationType.isCompatibleWith(variableType, isDiamond)) {
216	this.initialization.computeConversion(scope, variableType, initializationType);	225	this.initialization.computeConversion(scope, variableType, initializationType);
217	if (initializationType.needsUncheckedConversion(variableType)) {	226	if (initializationType.needsUncheckedConversion(variableType)) {
218	scope.problemReporter().unsafeTypeConversion(this.initialization, initializationType, variableType);	227	scope.problemReporter().unsafeTypeConversion(this.initialization, initializationType, variableType);

Lines 27-32 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java (-1 / +12 lines)
27	public class ParameterizedQualifiedTypeReference extends ArrayQualifiedTypeReference {	27	public class ParameterizedQualifiedTypeReference extends ArrayQualifiedTypeReference {
28		28
29	public TypeReference[][] typeArguments;	29	public TypeReference[][] typeArguments;
		30	public TypeBinding[] inferredTypeArgs;
30		31
31	/**	32	/**
32	* @param tokens	33	* @param tokens
Lines 37-42 Link Here
37		38
38	super(tokens, dim, positions);	39	super(tokens, dim, positions);
39	this.typeArguments = typeArguments;	40	this.typeArguments = typeArguments;
		41	this.inferredTypeArgs = null;
40	}	42	}
41	public void checkBounds(Scope scope) {	43	public void checkBounds(Scope scope) {
42	if (this.resolvedType == null) return;	44	if (this.resolvedType == null) return;
Lines 68-73 Link Here
68	* @return char[][]	70	* @return char[][]
69	*/	71	*/
70	public char [][] getParameterizedTypeName(){	72	public char [][] getParameterizedTypeName(){
		73	if ((this.bits & ASTNode.IsDiamond) != 0)
		74	return this.getTypeName();
71	int length = this.tokens.length;	75	int length = this.tokens.length;
72	char[][] qParamName = new char[length][];	76	char[][] qParamName = new char[length][];
73	for (int i = 0; i < length; i++) {	77	for (int i = 0; i < length; i++) {
Lines 223-228 Link Here
223	argTypes[j] = argType;	227	argTypes[j] = argType;
224	}	228	}
225	}	229	}
		230	if (argLength == 0 && (this.bits & ASTNode.IsDiamond) != 0 && this.inferredTypeArgs != null) {
		231	argTypes = this.inferredTypeArgs;
		232	}
226	if (argHasError) {	233	if (argHasError) {
227	return null;	234	return null;
228	}	235	}
Lines 344-350 Link Here
344	}	351	}
345	return output;	352	return output;
346	}	353	}
347		354
		355	public TypeBinding resolveType(BlockScope scope, boolean checkBounds, TypeBinding[] inferredArgs) {
		356	this.inferredTypeArgs = inferredArgs;
		357	return internalResolveType(scope, checkBounds);
		358	}
348	public TypeBinding resolveType(BlockScope scope, boolean checkBounds) {	359	public TypeBinding resolveType(BlockScope scope, boolean checkBounds) {
349	return internalResolveType(scope, checkBounds);	360	return internalResolveType(scope, checkBounds);
350	}	361	}

Lines 27-37 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java (+12 lines)
27	public class ParameterizedSingleTypeReference extends ArrayTypeReference {	27	public class ParameterizedSingleTypeReference extends ArrayTypeReference {
28		28
29	public TypeReference[] typeArguments;	29	public TypeReference[] typeArguments;
		30	public TypeBinding[] inferredTypeArgs;
30		31
31	public ParameterizedSingleTypeReference(char[] name, TypeReference[] typeArguments, int dim, long pos){	32	public ParameterizedSingleTypeReference(char[] name, TypeReference[] typeArguments, int dim, long pos){
32	super(name, dim, pos);	33	super(name, dim, pos);
33	this.originalSourceEnd = this.sourceEnd;	34	this.originalSourceEnd = this.sourceEnd;
34	this.typeArguments = typeArguments;	35	this.typeArguments = typeArguments;
		36	this.inferredTypeArgs = null;
35	}	37	}
36	public void checkBounds(Scope scope) {	38	public void checkBounds(Scope scope) {
37	if (this.resolvedType == null) return;	39	if (this.resolvedType == null) return;
Lines 57-62 Link Here
57	* @return char[][]	59	* @return char[][]
58	*/	60	*/
59	public char [][] getParameterizedTypeName(){	61	public char [][] getParameterizedTypeName(){
		62	if ((this.bits & ASTNode.IsDiamond) != 0)
		63	return this.getTypeName();
60	StringBuffer buffer = new StringBuffer(5);	64	StringBuffer buffer = new StringBuffer(5);
61	buffer.append(this.token).append('<');	65	buffer.append(this.token).append('<');
62	for (int i = 0, length = this.typeArguments.length; i < length; i++) {	66	for (int i = 0, length = this.typeArguments.length; i < length; i++) {
Lines 188-193 Link Here
188	argTypes[i] = argType;	192	argTypes[i] = argType;
189	}	193	}
190	}	194	}
		195	if (argLength == 0 && (this.bits & ASTNode.IsDiamond) != 0 && this.inferredTypeArgs != null) {
		196	argTypes = this.inferredTypeArgs;
		197	}
191	if (argHasError) {	198	if (argHasError) {
192	return null;	199	return null;
193	}	200	}
Lines 281-286 Link Here
281	return output;	288	return output;
282	}	289	}
283		290
		291	public TypeBinding resolveType(BlockScope scope, boolean checkBounds, TypeBinding[] inferredArgs) {
		292	this.inferredTypeArgs = inferredArgs;
		293	return internalResolveType(scope, null, checkBounds);
		294	}
		295
284	public TypeBinding resolveType(BlockScope scope, boolean checkBounds) {	296	public TypeBinding resolveType(BlockScope scope, boolean checkBounds) {
285	return internalResolveType(scope, null, checkBounds);	297	return internalResolveType(scope, null, checkBounds);
286	}	298	}

Lines 498-501 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java (+9 lines)
498	}	498	}
499	visitor.endVisit(this, scope);	499	visitor.endVisit(this, scope);
500	}	500	}
		501
		502	/**
		503	* @see org.eclipse.jdt.internal.compiler.ast.Expression#setExpectedType(org.eclipse.jdt.internal.compiler.lookup.TypeBinding)
		504	*/
		505	public void setExpectedType(TypeBinding expectedType) {
		506	this.expectedType = expectedType;
		507	if (this.expectedType != null && this.enclosingInstance != null)
		508	this.enclosingInstance.setExpectedType(this.expectedType.enclosingType());
		509	}
501	}	510	}

Lines 208-213 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TypeReference.java (+4 lines)
208	return internalResolveType(scope);	208	return internalResolveType(scope);
209	}	209	}
210		210
		211	public TypeBinding resolveType(BlockScope scope, boolean checkBounds, TypeBinding[] inferredArgs) {
		212	return internalResolveType(scope);
		213	}
		214
211	public TypeBinding resolveType(ClassScope scope) {	215	public TypeBinding resolveType(ClassScope scope) {
212	return internalResolveType(scope);	216	return internalResolveType(scope);
213	}	217	}

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java (-2 / +10 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2005, 2010 IBM Corporation and others.	2	* Copyright (c) 2005, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 31-36 Link Here
31	public ReferenceBinding[] memberTypes;	31	public ReferenceBinding[] memberTypes;
32	public MethodBinding[] methods;	32	public MethodBinding[] methods;
33	private ReferenceBinding enclosingType;	33	private ReferenceBinding enclosingType;
		34	private TypeBinding[] expectedArgumentTypes;
34		35
35	public ParameterizedTypeBinding(ReferenceBinding type, TypeBinding[] arguments, ReferenceBinding enclosingType, LookupEnvironment environment){	36	public ParameterizedTypeBinding(ReferenceBinding type, TypeBinding[] arguments, ReferenceBinding enclosingType, LookupEnvironment environment){
36	this.environment = environment;	37	this.environment = environment;
Lines 451-457 Link Here
451	public MethodBinding getExactConstructor(TypeBinding[] argumentTypes) {	452	public MethodBinding getExactConstructor(TypeBinding[] argumentTypes) {
452	int argCount = argumentTypes.length;	453	int argCount = argumentTypes.length;
453	MethodBinding match = null;	454	MethodBinding match = null;
454		455	this.expectedArgumentTypes = argumentTypes;
455	if ((this.tagBits & TagBits.AreMethodsComplete) != 0) { // have resolved all arg types & return type of the methods	456	if ((this.tagBits & TagBits.AreMethodsComplete) != 0) { // have resolved all arg types & return type of the methods
456	long range;	457	long range;
457	if ((range = ReferenceBinding.binarySearch(TypeConstants.INIT, this.methods)) >= 0) {	458	if ((range = ReferenceBinding.binarySearch(TypeConstants.INIT, this.methods)) >= 0) {
Lines 955-960 Link Here
955	// lazy init, since cannot do so during binding creation if during supertype connection	956	// lazy init, since cannot do so during binding creation if during supertype connection
956	if (currentType.arguments == null)	957	if (currentType.arguments == null)
957	currentType.initializeArguments(); // only for raw types	958	currentType.initializeArguments(); // only for raw types
		959	else if (currentType.arguments.length == 0) { // diamond case
		960	// this.expectedArgumentTypes should have the argument list
		961	if (currentType.expectedArgumentTypes != null && currentType.expectedArgumentTypes.length != 0) {
		962	return currentType.expectedArgumentTypes[originalVariable.rank];
		963	}
		964	return originalVariable;
		965	}
958	if (currentType.arguments != null)	966	if (currentType.arguments != null)
959	return currentType.arguments[originalVariable.rank];	967	return currentType.arguments[originalVariable.rank];
960	}	968	}




 * In addition to improving performance, caching also ensures there is no infinite regression
 * since per nature, the compatibility check is recursive through parameterized type arguments (122775)
 */
public boolean isCompatibleWith(TypeBinding otherType, boolean isDiamondCase) {
	if (isDiamondCase) {
		if (this.erasure() == otherType.erasure())
			return true;
	}
	return isCompatibleWith(otherType);
}
/**
 * Answer true if the receiver type can be assigned to the argument type (right)
 * In addition to improving performance, caching also ensures there is no infinite regression
 * since per nature, the compatibility check is recursive through parameterized type arguments (122775)
 */
public boolean isCompatibleWith(TypeBinding otherType) {
	if (otherType == this)
		return true;

Lines 1310-1315 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java (-1 / +13 lines)
1310	fieldDecl.binding = null;	1310	fieldDecl.binding = null;
1311	return null;	1311	return null;
1312	}	1312	}
		1313	if ((this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_7) &&
		1314	fieldDecl.type != null &&
		1315	((fieldDecl.type.bits & ASTNode.IsDiamond) != 0)) {
		1316	this.scope.problemReporter().incorrectArityForParameterizedType(fieldDecl.type, fieldType, Binding.NO_TYPES);
		1317	fieldDecl.binding = null;
		1318	return null;
		1319	}
1313	if (fieldType == TypeBinding.VOID) {	1320	if (fieldType == TypeBinding.VOID) {
1314	this.scope.problemReporter().variableTypeCannotBeVoid(fieldDecl);	1321	this.scope.problemReporter().variableTypeCannotBeVoid(fieldDecl);
1315	fieldDecl.binding = null;	1322	fieldDecl.binding = null;
Lines 1390-1395 Link Here
1390	final boolean reportUnavoidableGenericTypeProblems = this.scope.compilerOptions().reportUnavoidableGenericTypeProblems;	1397	final boolean reportUnavoidableGenericTypeProblems = this.scope.compilerOptions().reportUnavoidableGenericTypeProblems;
1391	boolean foundArgProblem = false;	1398	boolean foundArgProblem = false;
1392	Argument[] arguments = methodDecl.arguments;	1399	Argument[] arguments = methodDecl.arguments;
		1400	boolean isCompliant17 = this.scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_7;
1393	if (arguments != null) {	1401	if (arguments != null) {
1394	int size = arguments.length;	1402	int size = arguments.length;
1395	method.parameters = Binding.NO_PARAMETERS;	1403	method.parameters = Binding.NO_PARAMETERS;
Lines 1415-1420 Link Here
1415		1423
1416	if (parameterType == null) {	1424	if (parameterType == null) {
1417	foundArgProblem = true;	1425	foundArgProblem = true;
		1426	} else if (isCompliant17 && (arg.type.bits & ASTNode.IsDiamond) != 0) {
		1427	// a parameter type cannot use diamond construct
		1428	methodDecl.scope.problemReporter().incorrectArityForParameterizedType(arg.type, parameterType.original(), Binding.NO_TYPES);
		1429	foundArgProblem = true;
1418	} else if (parameterType == TypeBinding.VOID) {	1430	} else if (parameterType == TypeBinding.VOID) {
1419	methodDecl.scope.problemReporter().argumentTypeCannotBeVoid(this, methodDecl, arg);	1431	methodDecl.scope.problemReporter().argumentTypeCannotBeVoid(this, methodDecl, arg);
1420	foundArgProblem = true;	1432	foundArgProblem = true;
Lines 1436-1442 Link Here
1436	}	1448	}
1437		1449
1438	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=337799	1450	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=337799
1439	if (this.scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_7) {	1451	if (isCompliant17) {
1440	if ((method.tagBits & TagBits.AnnotationSafeVarargs) != 0) {	1452	if ((method.tagBits & TagBits.AnnotationSafeVarargs) != 0) {
1441	if (!method.isVarargs()) {	1453	if (!method.isVarargs()) {
1442	methodDecl.scope.problemReporter().safeVarargsOnFixedArityMethod(method);	1454	methodDecl.scope.problemReporter().safeVarargsOnFixedArityMethod(method);

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBinding.java (-1 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2010 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 1183-1186 Link Here
1183	public TypeVariableBinding[] typeVariables() {	1183	public TypeVariableBinding[] typeVariables() {
1184	return Binding.NO_TYPE_VARIABLES;	1184	return Binding.NO_TYPE_VARIABLES;
1185	}	1185	}
		1186
		1187	public boolean isCompatibleWith(TypeBinding variableType, boolean isDiamond){
		1188	return isCompatibleWith(variableType);
		1189	}
1186	}	1190	}

Return to bug 339478

Lines 1005-1010 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java (+12 lines)
1005	* In addition to improving performance, caching also ensures there is no infinite regression	1005	* In addition to improving performance, caching also ensures there is no infinite regression
1006	* since per nature, the compatibility check is recursive through parameterized type arguments (122775)	1006	* since per nature, the compatibility check is recursive through parameterized type arguments (122775)
1007	*/	1007	*/
		1008	public boolean isCompatibleWith(TypeBinding otherType, boolean isDiamondCase) {
		1009	if (isDiamondCase) {
		1010	if (this.erasure() == otherType.erasure())
		1011	return true;
		1012	}
		1013	return isCompatibleWith(otherType);
		1014	}
		1015	/**
		1016	* Answer true if the receiver type can be assigned to the argument type (right)
		1017	* In addition to improving performance, caching also ensures there is no infinite regression
		1018	* since per nature, the compatibility check is recursive through parameterized type arguments (122775)
		1019	*/
1008	public boolean isCompatibleWith(TypeBinding otherType) {	1020	public boolean isCompatibleWith(TypeBinding otherType) {
1009	if (otherType == this)	1021	if (otherType == this)
1010	return true;	1022	return true;

Lines 214-224 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/FieldDeclaration.java (-2 / +10 lines)
214	this.initialization.computeConversion(initializationScope, fieldType, initializationType);	214	this.initialization.computeConversion(initializationScope, fieldType, initializationType);
215	}	215	}
216	} else if ((initializationType = this.initialization.resolveType(initializationScope)) != null) {	216	} else if ((initializationType = this.initialization.resolveType(initializationScope)) != null) {
217		217	boolean isDiamond = false;
		218	if (this.initialization instanceof AllocationExpression) {
		219	AllocationExpression allocationExpression = (AllocationExpression) this.initialization;
		220	if (initializationScope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_7
		221	&& allocationExpression.type != null
		222	&& (allocationExpression.type.bits & ASTNode.IsDiamond) != 0) {
		223	isDiamond = true;
		224	}
		225	}
218	if (fieldType != initializationType) // must call before computeConversion() and typeMismatchError()	226	if (fieldType != initializationType) // must call before computeConversion() and typeMismatchError()
219	initializationScope.compilationUnitScope().recordTypeConversion(fieldType, initializationType);	227	initializationScope.compilationUnitScope().recordTypeConversion(fieldType, initializationType);
220	if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, fieldType)	228	if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, fieldType)
221	\|\| initializationType.isCompatibleWith(fieldType)) {	229	\|\| initializationType.isCompatibleWith(fieldType, isDiamond)) {
222	this.initialization.computeConversion(initializationScope, fieldType, initializationType);	230	this.initialization.computeConversion(initializationScope, fieldType, initializationType);
223	if (initializationType.needsUncheckedConversion(fieldType)) {	231	if (initializationType.needsUncheckedConversion(fieldType)) {
224	initializationScope.problemReporter().unsafeTypeConversion(this.initialization, initializationType, fieldType);	232	initializationScope.problemReporter().unsafeTypeConversion(this.initialization, initializationType, fieldType);