Projects >> xtext >>7acd5108809aad75f0a748367d0943945f48570c

Chunk
Conflicting content 
import org.eclipse.xtext.xbase.typesystem.util.DeclaratorTypeArgumentCollector;
import org.eclipse.xtext.xbase.typesystem.util.MergedBoundTypeArgument;
import org.eclipse.xtext.xbase.typesystem.util.TypeParameterSubstitutor;
<<<<<<< HEAD
=======
import org.eclipse.xtext.xbase.typesystem.util.UnboundTypeParameter;
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
import org.eclipse.xtext.xbase.typesystem.util.UnboundTypeParameterAwareTypeArgumentCollector;
import org.eclipse.xtext.xbase.typesystem.util.UnboundTypeParameterPreservingSubstitutor;
import org.eclipse.xtext.xbase.typesystem.util.UnboundTypeParameters;
Solution content 
import org.eclipse.xtext.xbase.typesystem.util.DeclaratorTypeArgumentCollector;
import org.eclipse.xtext.xbase.typesystem.util.MergedBoundTypeArgument;
import org.eclipse.xtext.xbase.typesystem.util.TypeParameterSubstitutor;
import org.eclipse.xtext.xbase.typesystem.util.UnboundTypeParameter;
import org.eclipse.xtext.xbase.typesystem.util.UnboundTypeParameterAwareTypeArgumentCollector;
import org.eclipse.xtext.xbase.typesystem.util.UnboundTypeParameterPreservingSubstitutor;
import org.eclipse.xtext.xbase.typesystem.util.UnboundTypeParameters;
File
XbaseTypeComputer.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
	
	protected void _computeTypes(final XClosure object, final ITypeComputationState state) {
		for(ITypeExpectation expectation: state.getImmediateExpectations()) {
<<<<<<< HEAD
			JvmTypeReference expectedClosureType = expectation.getExpectedType();
			Map expectedTypeParameterMapping = Collections.emptyMap();
			// TODO - closure has no expected type - has to be function or procedure
			ITypeComputationState closureBodyState = state;
			JvmOperation operation = null;
			List operationParameters = Collections.emptyList();
			final JvmTypeReference operationReturnType;
			TypeParameterSubstitutor substitutor = null;
			if (expectedClosureType != null) {
				operation = closures.findImplementingOperation(expectedClosureType, object.eResource());
				if (operation != null) {
					List rawTypes = rawTypeHelper.getAllRawTypes(expectedClosureType, object.eResource());
					List allTypeParameters = Lists.newArrayList();
					for(JvmType rawType: rawTypes) {
						if (rawType instanceof JvmTypeParameterDeclarator) {
							allTypeParameters.addAll(((JvmTypeParameterDeclarator) rawType).getTypeParameters());
						}
					}
					allTypeParameters.addAll(operation.getTypeParameters());
					ActualTypeArgumentCollector typeArgumentCollector = new UnboundTypeParameterAwareTypeArgumentCollector(allTypeParameters, services);
					JvmParameterizedTypeReference operationTypeDeclarator = services.getTypeReferences().createTypeRef(operation.getDeclaringType());
					typeArgumentCollector.populateTypeParameterMapping(operationTypeDeclarator, expectedClosureType);
					ListMultimap typeParameterMapping = typeArgumentCollector.getTypeParameterMapping();
					expectedTypeParameterMapping = Maps.newLinkedHashMap();
					for(JvmTypeParameter typeParamter: typeParameterMapping.keySet()) {
						MergedBoundTypeArgument boundTypeArgument = typeArgumentMerger.merge(typeParameterMapping.get(typeParamter));
						if (boundTypeArgument != null)
							expectedTypeParameterMapping.put(typeParamter, boundTypeArgument);
					}
					operationParameters = operation.getParameters();
					JvmTypeReference declaredReturnType = operation.getReturnType();
					substitutor = new UnboundTypeParameterPreservingSubstitutor(expectedTypeParameterMapping, services);
					operationReturnType = substitutor.substitute(declaredReturnType);
					if (operationReturnType == null) {
						throw new IllegalStateException();
					}
					closureBodyState = closureBodyState.fork().withExpectation(operationReturnType);
				} else {
					operationReturnType = null;
				}
=======
			List closureParameters = object.getFormalParameters();
			JvmTypeReference closureType = expectation.getExpectedType();
			JvmOperation operation = null;
			if (closureType == null) {
				// TODO - closure has no expected type - has to be function or procedure
				closureType = closures.createRawFunctionTypeRef(object, closureParameters.size(), false);
				operation = closures.findImplementingOperation(closureType, object.eResource());
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
			} else {
				operation = closures.findImplementingOperation(closureType, object.eResource());
				if (operation == null) {
Solution content 
	
	protected void _computeTypes(final XClosure object, final ITypeComputationState state) {
		for(ITypeExpectation expectation: state.getImmediateExpectations()) {
			List closureParameters = object.getFormalParameters();
			JvmTypeReference closureType = expectation.getExpectedType();
			JvmOperation operation = null;
			if (closureType == null) {
				// TODO - closure has no expected type - has to be function or procedure
				closureType = closures.createRawFunctionTypeRef(object, closureParameters.size(), false);
				operation = closures.findImplementingOperation(closureType, object.eResource());
			} else {
				operation = closures.findImplementingOperation(closureType, object.eResource());
				if (operation == null) {
File
XbaseTypeComputer.java
Developer's decision
Version 2
Kind of conflict
Comment
If statement
Method invocation
Variable
Chunk
Conflicting content 
			} else {
				typeAssigner.assignType(closureParameter, services.getTypeReferences().getTypeForName(Object.class, closureParameter));
			}
<<<<<<< HEAD
			ITypeComputationResult expressionResult = typeAssigner.getForkedState().computeTypes(object.getExpression());
			if (expectedClosureType == null || operationReturnType == null) {
				final List closureParameterTypes = Lists.newArrayListWithCapacity(closureParameters.size());
				for(JvmFormalParameter parameter: closureParameters) {
					closureParameterTypes.add(expressionResult.getActualType(parameter));
				}
				JvmTypeReference expressionResultType = expressionResult.getActualExpressionType();
				expressionResultType = new TypeParameterSubstitutor(Collections.emptyMap(), services) {
					@Override
					public JvmTypeReference doVisitAnyTypeReference(JvmAnyTypeReference reference, Set visited) {
						return operationReturnType;
					}
					@Override
					protected JvmTypeReference handleNullReference(Set visited) {
						return operationReturnType;
					}
					@Override
					public JvmTypeReference doVisitComputedTypeReference(XComputedTypeReference reference, Set visited) {
						if (closureParameterTypes.contains(reference)) {
							return reference;
						}
						return super.doVisitComputedTypeReference(reference, visited);
					}
				}.visit(expressionResultType, Sets.newHashSet());
				if (expressionResultType == null) {
					expressionResultType = services.getTypeReferences().getTypeForName(Object.class, object);
				}
				closureType[0] = closures.createFunctionTypeRef(object, closureParameterTypes, expressionResultType, true);	
				expectation.acceptActualType(closureType[0], ConformanceHint.DEMAND_CONVERSION);
			} else {
				JvmTypeReference closureBodyType = expressionResult.getActualExpressionType();
				JvmType rawReturnType = operationReturnType.getType();
				if (rawReturnType instanceof JvmTypeParameter) {
					if (closureBodyType instanceof XComputedTypeReference && UnboundTypeParameters.isUnboundTypeParameter((XComputedTypeReference) closureBodyType)) {
						substitutor.enhanceMapping(Collections.singletonMap((JvmTypeParameter)rawReturnType, 
								new MergedBoundTypeArgument(closureBodyType, VarianceInfo.INVARIANT)));
					} else {
						substitutor.enhanceMapping(Collections.singletonMap((JvmTypeParameter)rawReturnType, 
								new MergedBoundTypeArgument(primitives.asWrapperTypeIfPrimitive(closureBodyType), VarianceInfo.INVARIANT)));
					}
				} else {
					substitutor.enhanceMapping(new DeclaratorTypeArgumentCollector().getTypeParameterMapping(closureBodyType));
				}
				JvmType expectedRawType = expectedClosureType.getType();
				closureType[0] = substitutor.substitute(services.getTypeReferences().createTypeRef(expectedRawType));
				expectation.acceptActualType(closureType[0], ConformanceHint.DEMAND_CONVERSION);
=======
		}
		return typeAssigner.getForkedState();
	}

	protected JvmTypeReference getSubstitutedClosureReturnType(JvmOperation operation,
			UnboundTypeParameterPreservingSubstitutor substitutor) {
		JvmTypeReference result = substitutor.substitute(operation.getReturnType());
		if (result == null) {
			throw new IllegalStateException("result may not be null");
		}
		return result;
	}

	protected Map getTypeParameterMapping(XClosure object,
			JvmTypeReference closureType, JvmOperation operation, ITypeComputationState state) {
		List allTypeParameters = collectAllTypeParameters(closureType, operation);
		ListMultimap typeParameterMapping = getClosureTypeParameterMapping(
				closureType, operation, allTypeParameters);
		
		Map expectedTypeParameterMapping = Maps.newLinkedHashMap();
		for(JvmTypeParameter typeParameter: allTypeParameters) {
			List boundInformation = typeParameterMapping.get(typeParameter);
			if (boundInformation.isEmpty()) {
				UnboundTypeParameter unboundTypeParameter = state.createUnboundTypeParameter(object, typeParameter);
				XComputedTypeReference typeReference = services.getXtypeFactory().createXComputedTypeReference();
				typeReference.setTypeProvider(unboundTypeParameter);
				// TODO use VarianceInfo.IN / .OUT respectively if direct arg in operation
				MergedBoundTypeArgument boundTypeArgument = new MergedBoundTypeArgument(typeReference, VarianceInfo.INVARIANT);
				expectedTypeParameterMapping.put(typeParameter, boundTypeArgument);
			} else {
				MergedBoundTypeArgument boundTypeArgument = typeArgumentMerger.merge(typeParameterMapping.get(typeParameter));
				expectedTypeParameterMapping.put(typeParameter, boundTypeArgument);
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
			}
		}
		return expectedTypeParameterMapping;
Solution content 
		
			} else {
				typeAssigner.assignType(closureParameter, services.getTypeReferences().getTypeForName(Object.class, closureParameter));
			}
		}
		return typeAssigner.getForkedState();
	}

	protected JvmTypeReference getSubstitutedClosureReturnType(JvmOperation operation,
			UnboundTypeParameterPreservingSubstitutor substitutor) {
		JvmTypeReference result = substitutor.substitute(operation.getReturnType());
		if (result == null) {
			throw new IllegalStateException("result may not be null");
		}
		return result;
	}

	protected Map getTypeParameterMapping(XClosure object,
			JvmTypeReference closureType, JvmOperation operation, ITypeComputationState state) {
		List allTypeParameters = collectAllTypeParameters(closureType, operation);
		ListMultimap typeParameterMapping = getClosureTypeParameterMapping(
				closureType, operation, allTypeParameters);
		Map expectedTypeParameterMapping = Maps.newLinkedHashMap();
		for(JvmTypeParameter typeParameter: allTypeParameters) {
			List boundInformation = typeParameterMapping.get(typeParameter);
			if (boundInformation.isEmpty()) {
				UnboundTypeParameter unboundTypeParameter = state.createUnboundTypeParameter(object, typeParameter);
				XComputedTypeReference typeReference = services.getXtypeFactory().createXComputedTypeReference();
				typeReference.setTypeProvider(unboundTypeParameter);
				// TODO use VarianceInfo.IN / .OUT respectively if direct arg in operation
				MergedBoundTypeArgument boundTypeArgument = new MergedBoundTypeArgument(typeReference, VarianceInfo.INVARIANT);
				expectedTypeParameterMapping.put(typeParameter, boundTypeArgument);
			} else {
				MergedBoundTypeArgument boundTypeArgument = typeArgumentMerger.merge(typeParameterMapping.get(typeParameter));
				expectedTypeParameterMapping.put(typeParameter, boundTypeArgument);
			}
		}
		return expectedTypeParameterMapping;
File
XbaseTypeComputer.java
Developer's decision
Version 2
Kind of conflict
Array access
Comment
For statement
If statement
Method declaration
Method invocation
Method signature
Return statement
Variable
Chunk
Conflicting content 
import org.eclipse.xtext.xtype.XComputedTypeReference;
import org.eclipse.xtext.xbase.typesystem.util.DeferredTypeParameterHintCollector;
import org.eclipse.xtext.xbase.typesystem.util.MergedBoundTypeArgument;
import org.eclipse.xtext.xbase.typesystem.util.UnboundTypeParameter;
<<<<<<< HEAD
=======
import org.eclipse.xtext.xbase.typesystem.util.UnboundTypeParameters;
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
import org.eclipse.xtext.xbase.typing.IJvmTypeReferenceProvider;
Solution content 
import org.eclipse.xtext.xbase.typesystem.util.DeferredTypeParameterHintCollector;
import org.eclipse.xtext.xbase.typesystem.util.MergedBoundTypeArgument;
import org.eclipse.xtext.xbase.typesystem.util.UnboundTypeParameter;
import org.eclipse.xtext.xbase.typesystem.util.UnboundTypeParameters;
import org.eclipse.xtext.xbase.typing.IJvmTypeReferenceProvider;
import org.eclipse.xtext.xtype.XComputedTypeReference;
File
AbstractLinkingCandidate.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
		return null;
	}
	
<<<<<<< HEAD
	protected void deferredBindTypeArguments(JvmTypeReference expectedType, JvmTypeReference type) {
		if (expectedType != null) { 
			// TODO expectation#hasTypeParameters / isUnresolved
			DeferredTypeParameterHintCollector collector = new DeferredTypeParameterHintCollector(getState().getServices());
=======
	protected void deferredBindTypeArguments(ITypeExpectation expectation, JvmTypeReference type) {
		JvmTypeReference expectedType = expectation.getExpectedType();
		if (expectedType != null) { 
			// TODO expectation#hasTypeParameters / isUnresolved to improve the runtime performance
			DeferredTypeParameterHintCollector collector = new DeferredTypeParameterHintCollector(getState().getServices()) {
				@Override
				protected void addHint(UnboundTypeParameter typeParameter, JvmTypeReference reference) {
					JvmTypeParameter referencedTypeParameter = getTypeParameter(reference);
					if (referencedTypeParameter != null) {
						if (!getDeclaratorParameterMapping().containsKey(referencedTypeParameter)
								&& !getDeclaredTypeParameters().contains(referencedTypeParameter)) {
							return;
						}
					}
					super.addHint(typeParameter, reference);
				}
			};
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
			collector.processPairedReferences(expectedType, type);
		}
	}
Solution content 
		return null;
	}
	
	protected void deferredBindTypeArguments(ITypeExpectation expectation, JvmTypeReference type) {
		JvmTypeReference expectedType = expectation.getExpectedType();
		if (expectedType != null) { 
			// TODO expectation#hasTypeParameters / isUnresolved to improve the runtime performance
			DeferredTypeParameterHintCollector collector = new DeferredTypeParameterHintCollector(getState().getServices()) {
				@Override
				protected void addHint(UnboundTypeParameter typeParameter, JvmTypeReference reference) {
					JvmTypeParameter referencedTypeParameter = getTypeParameter(reference);
					if (referencedTypeParameter != null) {
						if (!getDeclaratorParameterMapping().containsKey(referencedTypeParameter)
								&& !getDeclaredTypeParameters().contains(referencedTypeParameter)) {
							return;
						}
					}
					super.addHint(typeParameter, reference);
				}
			};
			collector.processPairedReferences(expectedType, type);
		}
	}
File
AbstractLinkingCandidate.java
Developer's decision
Version 2
Kind of conflict
Comment
If statement
Method invocation
Method signature
Variable
Chunk
Conflicting content 
	
	protected StackedResolvedTypes resolveArgumentType(XExpression argument, JvmTypeReference declaredType, AbstractTypeComputationState argumentState) {
		StackedResolvedTypes result = argumentState.computeTypesWithoutMerge(argument);
<<<<<<< HEAD
=======
		
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
		return result;
	}
Solution content 
	
	protected StackedResolvedTypes resolveArgumentType(XExpression argument, JvmTypeReference declaredType, AbstractTypeComputationState argumentState) {
		StackedResolvedTypes result = argumentState.computeTypesWithoutMerge(argument);
		
		return result;
	}
File
AbstractLinkingCandidate.java
Developer's decision
Version 1
Kind of conflict
Blank
Chunk
Conflicting content 
import org.eclipse.xtext.xbase.typing.IJvmTypeReferenceProvider;
import org.eclipse.xtext.xtype.XComputedTypeReference;

<<<<<<< HEAD
=======
import com.google.common.collect.ListMultimap;
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
Solution content 
import org.eclipse.xtext.xbase.typing.IJvmTypeReferenceProvider;
import org.eclipse.xtext.xtype.XComputedTypeReference;

import com.google.common.collect.ListMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
File
AbstractLinkingCandidateWithTypeParameter.java
Developer's decision
Version 2
Kind of conflict
Import
Chunk
Conflicting content 
	protected AbstractLinkingCandidateWithTypeParameter(XExpression expression, IEObjectDescription description,
			ExpressionTypeComputationState state) {
		super(expression, description, state);
<<<<<<< HEAD
=======
		this.typeParameterMapping = Multimaps2.newLinkedHashListMultimap(2, 3);
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
	}

	public void accept(ObservableTypeExpectation expectation, JvmTypeReference actual, ConformanceHint conformanceHint) {
Solution content 
	protected AbstractLinkingCandidateWithTypeParameter(XExpression expression, IEObjectDescription description,
			ExpressionTypeComputationState state) {
		super(expression, description, state);
		this.typeParameterMapping = Multimaps2.newLinkedHashListMultimap(2, 3);
	}

	public void accept(ObservableTypeExpectation expectation, JvmTypeReference actual, ConformanceHint conformanceHint) {
File
AbstractLinkingCandidateWithTypeParameter.java
Developer's decision
Version 2
Kind of conflict
Attribute
Method invocation
Chunk
Conflicting content 
	public void accept(ObservableTypeExpectation expectation, JvmTypeReference actual, ConformanceHint conformanceHint) {
		// TODO traverse the expectation and read the actual parameter data from the actual mapping by means of a type parameter substitutor
<<<<<<< HEAD
		if (expectation.isNoTypeExpectation() || actual instanceof JvmAnyTypeReference) {
=======
		JvmTypeReference expectedType = expectation.getExpectedType();
		if (expectedType == null || actual instanceof JvmAnyTypeReference) {
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
			return;
		}
		JvmTypeReference expectedType = expectation.getExpectedType();
Solution content 
	public void accept(ObservableTypeExpectation expectation, JvmTypeReference actual, ConformanceHint conformanceHint) {
		// TODO traverse the expectation and read the actual parameter data from the actual mapping by means of a type parameter substitutor
		JvmTypeReference expectedType = expectation.getExpectedType();
		if (expectedType == null || actual instanceof JvmAnyTypeReference) {
			return;
		}
		JvmTypeReference expectedType = expectation.getExpectedType();
File
AbstractLinkingCandidateWithTypeParameter.java
Developer's decision
Version 2
Kind of conflict
If statement
Method invocation
Variable
Chunk
Conflicting content 
				}
			}
		} else if (expectedType.getType() instanceof JvmTypeParameter) {
<<<<<<< HEAD
			throw new IllegalStateException("Expectation may not be a type parameter since it should have been resolved.");
=======
			JvmTypeReference wrappedActual = asWrapperType(actual);
			typeParameterMapping.put((JvmTypeParameter) expectedType.getType(), new BoundTypeArgument(wrappedActual, BoundTypeArgumentSource.INFERRED, new Object(), VarianceInfo.OUT, VarianceInfo.OUT));
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
		} else {
			resolveAgainstActualType(expectedType, actual);
		}
Solution content 
		}
				}
			}
		} else if (expectedType.getType() instanceof JvmTypeParameter) {
			JvmTypeReference wrappedActual = asWrapperType(actual);
			typeParameterMapping.put((JvmTypeParameter) expectedType.getType(), new BoundTypeArgument(wrappedActual, BoundTypeArgumentSource.INFERRED, new Object(), VarianceInfo.OUT, VarianceInfo.OUT));
		} else {
			resolveAgainstActualType(expectedType, actual);
File
AbstractLinkingCandidateWithTypeParameter.java
Developer's decision
Version 2
Kind of conflict
Method invocation
Throw statement
Variable
Chunk
Conflicting content 
		for(StackedResolvedTypes pending: stackedResolvedTypes) {
			pending.mergeIntoParent();
		}
<<<<<<< HEAD
		for(MergedBoundTypeArgument mergedBoundTypeArgument: getFeatureTypeParameterMapping().values()) {
			JvmTypeReference reference = mergedBoundTypeArgument.getTypeReference();
			if (reference instanceof XComputedTypeReference && UnboundTypeParameters.isUnboundTypeParameter((XComputedTypeReference) reference)) {
				UnboundTypeParameter typeParameter = (UnboundTypeParameter) ((XComputedTypeReference) reference).getTypeProvider();
				if(typeParameter.hasHints()) {
					typeParameter.getTypeReference();
				}
			}
		}
=======
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
		List expectations = getState().getImmediateExpectations();
		for(ITypeExpectation expectation: expectations) {
			// TODO implement bounds / type parameter resolution
Solution content 
		for(StackedResolvedTypes pending: stackedResolvedTypes) {
			pending.mergeIntoParent();
		}
		List expectations = getState().getImmediateExpectations();
		for(ITypeExpectation expectation: expectations) {
			// TODO implement bounds / type parameter resolution
File
AbstractLinkingCandidateWithTypeParameter.java
Developer's decision
Version 2
Kind of conflict
For statement
Chunk
Conflicting content 
	}

	protected Map getFeatureTypeParameterMapping() {
<<<<<<< HEAD
		if (featureTypeParameterMapping == null) {
			Map map = Maps.newLinkedHashMap();
			initializeFeatureTypeParameterMapping(map);
			featureTypeParameterMapping = map;
		}
		return featureTypeParameterMapping;
	}
	
	protected void initializeFeatureTypeParameterMapping(Map result) {
		List typeParameters = getDeclaredTypeParameters();
		for(JvmTypeParameter typeParameter: typeParameters) {
			if (!result.containsKey(typeParameter)) {
				XComputedTypeReference reference = getState().getServices().getXtypeFactory().createXComputedTypeReference();
				RootUnboundTypeParameter unboundParameter = getState().getResolvedTypes().createUnboundTypeParameter(getExpression(), typeParameter);
				reference.setTypeProvider(unboundParameter);
				result.put(typeParameter, new MergedBoundTypeArgument(reference, VarianceInfo.INVARIANT));
=======
		Map consolidatedMap = Maps.newLinkedHashMap();
		for(JvmTypeParameter typeParameter: typeParameterMapping.keySet()) {
			List boundTypeArguments = typeParameterMapping.get(typeParameter);
			MergedBoundTypeArgument mergedTypeArguments = getState().getTypeArgumentMerger().merge(boundTypeArguments);
			if (mergedTypeArguments != null) {
				consolidatedMap.put(typeParameter, mergedTypeArguments);
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
			}
		}
	}
Solution content 
	}

	protected Map getFeatureTypeParameterMapping() {
		Map consolidatedMap = Maps.newLinkedHashMap();
		for(JvmTypeParameter typeParameter: typeParameterMapping.keySet()) {
			List boundTypeArguments = typeParameterMapping.get(typeParameter);
			MergedBoundTypeArgument mergedTypeArguments = getState().getTypeArgumentMerger().merge(boundTypeArguments);
			if (mergedTypeArguments != null) {
				consolidatedMap.put(typeParameter, mergedTypeArguments);
			}
		}
	}
File
AbstractLinkingCandidateWithTypeParameter.java
Developer's decision
Version 2
Kind of conflict
Attribute
For statement
If statement
Method invocation
Method signature
Return statement
Variable
Chunk
Conflicting content 
			@Nullable
			return Collections.singletonList(result);
		}
		// TODO reuse this information later on
<<<<<<< HEAD
		final Map demandComputedTypes = Maps.newLinkedHashMap();
		DelegatingResolvedTypes demandResolvedTypes = new DelegatingResolvedTypes(resolvedTypes) {
=======
//		final Map demandComputedTypes = Maps.newLinkedHashMap();
		
		StackedResolvedTypes demandComputedTypes = new StackedResolvedTypes(resolvedTypes);
		final AbstractTypeComputationState forked = fork().withNonVoidExpectation(demandComputedTypes);
		AbstractDelegatingResolvedTypes demandResolvedTypes = new AbstractDelegatingResolvedTypes() {
			
			@Override
			protected IResolvedTypes getDelegate() {
				return forked.getResolvedTypes();
			}
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
			
			@Override
Solution content 
			return Collections.singletonList(result);
		}
		// TODO reuse this information later on
//		final Map demandComputedTypes = Maps.newLinkedHashMap();
		
		StackedResolvedTypes demandComputedTypes = new StackedResolvedTypes(resolvedTypes);
		final AbstractTypeComputationState forked = fork().withNonVoidExpectation(demandComputedTypes);
		AbstractDelegatingResolvedTypes demandResolvedTypes = new AbstractDelegatingResolvedTypes() {
			
			@Override
			protected IResolvedTypes getDelegate() {
				return forked.getResolvedTypes();
			}
			
			@Override
			@Nullable
File
AbstractTypeComputationState.java
Developer's decision
Version 2
Kind of conflict
Comment
Method invocation
Variable
Chunk
Conflicting content 
			}
			public JvmTypeReference getActualType(@Nullable XExpression expression) {
				JvmTypeReference type = super.getActualType(expression);
				if (type == null && expression != null) {
<<<<<<< HEAD
					StackedResolvedTypes previouslyComputed = demandComputedTypes.get(expression);
					if (previouslyComputed != null) {
						return previouslyComputed.getActualType(expression);
					}
					AbstractTypeComputationState expressionState = fork().withNonVoidExpectation();
					StackedResolvedTypes result = expressionState.computeTypesWithoutMerge(expression);
					if (result != null) {
						demandComputedTypes.put(expression, result);
						return result.getActualType(expression);
					}
					return null;
=======
					ITypeComputationResult result = forked.computeTypes(expression);
					return result.getActualExpressionType();
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
				}
				return type;
Solution content 
				return type;
			}
					return result.getActualExpressionType();
			public JvmTypeReference getActualType(@Nullable XExpression expression) {
				JvmTypeReference type = super.getActualType(expression);
				if (type == null && expression != null) {
					ITypeComputationResult result = forked.computeTypes(expression);
				}
File
AbstractTypeComputationState.java
Developer's decision
Version 2
Kind of conflict
If statement
Method invocation
Return statement
Variable
Chunk
Conflicting content 
				featureCall, XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE, featureScopeSession, demandResolvedTypes);
		List resultList = Lists.newArrayList();
		for(IEObjectDescription description: descriptions) {
<<<<<<< HEAD
			resultList.add(createCandidate(featureCall, demandComputedTypes.values(), description));
=======
			resultList.add(createCandidate(featureCall, demandComputedTypes, description));
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
		}
		if (resultList.isEmpty()) {
			throw new UnsupportedOperationException("TODO Add error candidate");
Solution content 
				featureCall, XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE, featureScopeSession, demandResolvedTypes);
		List resultList = Lists.newArrayList();
		for(IEObjectDescription description: descriptions) {
			resultList.add(createCandidate(featureCall, demandComputedTypes, description));
		}
		if (resultList.isEmpty()) {
			throw new UnsupportedOperationException("TODO Add error candidate");
File
AbstractTypeComputationState.java
Developer's decision
Version 2
Kind of conflict
Method invocation
Chunk
Conflicting content 
		return resultList;
	}
	
<<<<<<< HEAD
	protected IFeatureLinkingCandidate createCandidate(XAbstractFeatureCall featureCall, final Collection collection, IEObjectDescription description) {
		StackedResolvedTypes stackedResolvedTypes = new ExpressionAwareStackedResolvedTypes(resolvedTypes, featureCall) {
			@Override
			protected void mergeIntoParent() {
				super.mergeIntoParent();
//				for(StackedResolvedTypes other: collection) {
//					other.mergeIntoParent();
//				}
			}
		};
		ExpressionTypeComputationState state = createExpressionComputationState(featureCall, stackedResolvedTypes);
=======
	protected IFeatureLinkingCandidate createCandidate(XAbstractFeatureCall featureCall, final StackedResolvedTypes demandComputedTypes, IEObjectDescription description) {
		if (description instanceof BucketedEObjectDescription) {
			BucketedEObjectDescription casted = (BucketedEObjectDescription) description;
			if (casted.getReceiverType() != null) {
//				final StackedResolvedTypes resolvedTypes = new StackedResolvedTypes(demandComputedTypes);
				ExpressionTypeComputationState state = createExpressionComputationState(featureCall, demandComputedTypes);
				return new FeatureLinkingCandidate(featureCall, description, state);
			}
		}
		final StackedResolvedTypes resolvedTypes = new StackedResolvedTypes(this.resolvedTypes);
		ExpressionTypeComputationState state = createExpressionComputationState(featureCall, resolvedTypes);
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
		return new FeatureLinkingCandidate(featureCall, description, state);
	}
Solution content 
		return resultList;
	}
	
	protected IFeatureLinkingCandidate createCandidate(XAbstractFeatureCall featureCall, final StackedResolvedTypes demandComputedTypes, IEObjectDescription description) {
		if (description instanceof BucketedEObjectDescription) {
			BucketedEObjectDescription casted = (BucketedEObjectDescription) description;
			if (casted.getReceiverType() != null) {
//				final StackedResolvedTypes resolvedTypes = new StackedResolvedTypes(demandComputedTypes);
				ExpressionTypeComputationState state = createExpressionComputationState(featureCall, demandComputedTypes);
				return new FeatureLinkingCandidate(featureCall, description, state);
			}
		}
		final StackedResolvedTypes resolvedTypes = new StackedResolvedTypes(this.resolvedTypes);
		ExpressionTypeComputationState state = createExpressionComputationState(featureCall, resolvedTypes);
		return new FeatureLinkingCandidate(featureCall, description, state);
	}
File
AbstractTypeComputationState.java
Developer's decision
Version 2
Kind of conflict
If statement
Method invocation
Method signature
Variable
Chunk
Conflicting content 
	}
	
	@Override
<<<<<<< HEAD
	protected void initializeFeatureTypeParameterMapping(Map result) {
=======
	protected Map getFeatureTypeParameterMapping() {
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
		JvmDeclaredType createdType = getConstructor().getDeclaringType();
		if (createdType instanceof JvmTypeParameterDeclarator) {
			List typeArguments = getConstructorCall().getTypeArguments();
Solution content 
	}
	
	@Override
	protected Map getFeatureTypeParameterMapping() {
		JvmDeclaredType createdType = getConstructor().getDeclaringType();
		if (createdType instanceof JvmTypeParameterDeclarator) {
			List typeArguments = getConstructorCall().getTypeArguments();
File
ConstructorLinkingCandidate.java
Developer's decision
Version 2
Kind of conflict
Method signature
Chunk
Conflicting content 
	}
	
	@Override
<<<<<<< HEAD
	protected void initializeFeatureTypeParameterMapping(Map result) {
=======
	protected Map getFeatureTypeParameterMapping() {
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
		JvmIdentifiableElement feature = getFeature();
		if (feature instanceof JvmTypeParameterDeclarator) {
			List typeArguments = getFeatureCall().getTypeArguments();
Solution content 
	}
	
	@Override
	protected Map getFeatureTypeParameterMapping() {
		JvmIdentifiableElement feature = getFeature();
		if (feature instanceof JvmTypeParameterDeclarator) {
			List typeArguments = getFeatureCall().getTypeArguments();
File
FeatureLinkingCandidate.java
Developer's decision
Version 2
Kind of conflict
Method signature
Chunk
Conflicting content 
	public ActualTypeArgumentCollector(List parametersToBeMapped, BoundTypeArgumentSource defaultSource, CommonTypeComputationServices services) {
		super(services);
		this.parametersToBeMapped = parametersToBeMapped;
<<<<<<< HEAD
=======
		this.defaultSource = defaultSource;
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
		typeParameterMapping = Multimaps2.newLinkedHashListMultimap(parametersToBeMapped.size(), 3);
	}
Solution content 
	public ActualTypeArgumentCollector(List parametersToBeMapped, BoundTypeArgumentSource defaultSource, CommonTypeComputationServices services) {
		super(services);
		this.parametersToBeMapped = parametersToBeMapped;
		this.defaultSource = defaultSource;
		typeParameterMapping = Multimaps2.newLinkedHashListMultimap(parametersToBeMapped.size(), 3);
	}
File
ActualTypeArgumentCollector.java
Developer's decision
Version 2
Kind of conflict
Attribute
Chunk
Conflicting content 
	public JvmTypeReference doVisitParameterizedTypeReference(JvmParameterizedTypeReference reference, Set visiting) {
		JvmType type = reference.getType();
		if (type instanceof JvmTypeParameter) {
<<<<<<< HEAD
			JvmTypeReference result = getBoundTypeArgument(reference, (JvmTypeParameter) type, visiting);
			if (result != null) {
				return result;
=======
			MergedBoundTypeArgument boundTypeArgument = typeParameterMapping.get(type);
			if (boundTypeArgument != null && boundTypeArgument.getTypeReference() != reference) {
				JvmTypeReference result = visit(boundTypeArgument.getTypeReference(), visiting);
				if (result != null) {
					return result;
				}
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
			}
		}
		JvmParameterizedTypeReference result = services.getTypesFactory().createJvmParameterizedTypeReference();
Solution content 
	public JvmTypeReference doVisitParameterizedTypeReference(JvmParameterizedTypeReference reference, Set visiting) {
		JvmType type = reference.getType();
		if (type instanceof JvmTypeParameter) {
			MergedBoundTypeArgument boundTypeArgument = typeParameterMapping.get(type);
			if (boundTypeArgument != null && boundTypeArgument.getTypeReference() != reference) {
				JvmTypeReference result = visit(boundTypeArgument.getTypeReference(), visiting);
				if (result != null) {
					return result;
				}
			}
		}
		JvmParameterizedTypeReference result = services.getTypesFactory().createJvmParameterizedTypeReference();
File
TypeParameterSubstitutor.java
Developer's decision
Version 2
Kind of conflict
If statement
Method invocation
Return statement
Variable
Chunk
Conflicting content 
/**
 * @author Sebastian Zarnekow - Initial contribution and API
 * @noextend This class is not intended to be subclassed by clients.
<<<<<<< HEAD
 * TODO JavaDoc
=======
 * TODO JavaDoc, is this an interface?
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
 */
public abstract class UnboundTypeParameter extends AbstractReentrantTypeReferenceProvider {
Solution content 
/**
 * @author Sebastian Zarnekow - Initial contribution and API
 * @noextend This class is not intended to be subclassed by clients.
 * TODO JavaDoc, is this an interface?
 */
public abstract class UnboundTypeParameter extends AbstractReentrantTypeReferenceProvider {
File
UnboundTypeParameter.java
Developer's decision
Version 2
Kind of conflict
Comment
Chunk
Conflicting content 
	public abstract boolean isComputed();
	
	public abstract Object getHandle();
<<<<<<< HEAD
	
	public abstract boolean hasHints();
=======
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
	
	@Override
	public String toString() {
Solution content 
	public abstract boolean isComputed();
	
	public abstract Object getHandle();
	
	@Override
	public String toString() {
File
UnboundTypeParameter.java
Developer's decision
Version 2
Kind of conflict
Method interface
Chunk
Conflicting content 
/**
 * @author Sebastian Zarnekow - Initial contribution and API 
<<<<<<< HEAD
 * TODO JavaDoc, toString
=======
 * TODO JavaDoc, toString, inline into super type if only subtype and super type not used besides in tests
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
 */
public class UnboundTypeParameterAwareTypeArgumentCollector extends ActualTypeArgumentCollector {
Solution content 
/**
 * @author Sebastian Zarnekow - Initial contribution and API 
 * TODO JavaDoc, toString, inline into super type if only subtype and super type not used besides in tests
 */
public class UnboundTypeParameterAwareTypeArgumentCollector extends ActualTypeArgumentCollector {
File
UnboundTypeParameterAwareTypeArgumentCollector.java
Developer's decision
Version 2
Kind of conflict
Comment
Chunk
Conflicting content 
					}
				}
			}
<<<<<<< HEAD
			typeParameter.acceptHint(boundByInferrence(param));
=======
			typeParameter.acceptHint(boundByDefaultSource(param));
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
			return null;
		}
		return super.doVisitComputedTypeReference(reference, param);
Solution content 
					}
				}
			}
			typeParameter.acceptHint(boundByDefaultSource(param));
			return null;
		}
		return super.doVisitComputedTypeReference(reference, param);
File
UnboundTypeParameterAwareTypeArgumentCollector.java
Developer's decision
Version 2
Kind of conflict
Method invocation
Chunk
Conflicting content 
							// register synonym type param resolution et al for the actual type in the given UnboundTypeParameter
						}
					} else {
<<<<<<< HEAD
						typeParameter.acceptHint(boundByInferrence(declaration));
=======
						typeParameter.acceptHint(boundByDefaultSource(declaration));
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
					}
					return null;
				}
Solution content 
							// register synonym type param resolution et al for the actual type in the given UnboundTypeParameter
						}
					} else {
						typeParameter.acceptHint(boundByDefaultSource(declaration));
					}
					return null;
				}
File
UnboundTypeParameterAwareTypeArgumentCollector.java
Developer's decision
Version 2
Kind of conflict
Method invocation
Chunk
Conflicting content 
  private ITypeProvider typeProvider;
  
  public void resolvesTo(final String expression, final String type) throws Exception {
<<<<<<< HEAD
    final XExpression xExpression = this.expression(expression, false);
=======
    String _replace = expression.replace("$$", "org::eclipse::xtext::xbase::lib::");
    final XExpression xExpression = this.expression(_replace, false);
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
    IBatchTypeResolver _typeResolver = this.getTypeResolver();
    final IResolvedTypes resolvedTypes = _typeResolver.resolveTypes(xExpression);
    final JvmTypeReference resolvedType = resolvedTypes.getActualType(xExpression);
Solution content 
  private ITypeProvider typeProvider;
  
  public void resolvesTo(final String expression, final String type) throws Exception {
    String _replace = expression.replace("$$", "org::eclipse::xtext::xbase::lib::");
    final XExpression xExpression = this.expression(_replace, false);
    IBatchTypeResolver _typeResolver = this.getTypeResolver();
    final IResolvedTypes resolvedTypes = _typeResolver.resolveTypes(xExpression);
    final JvmTypeReference resolvedType = resolvedTypes.getActualType(xExpression);
File
BatchTypeResolverTest.java
Developer's decision
Version 2
Kind of conflict
Method invocation
Variable
Chunk
Conflicting content 
    }
  }
  
<<<<<<< HEAD
=======
  public void assertExpressionTypeIsResolved(final XExpression expression, final IResolvedTypes types) {
    final JvmTypeReference type = types.getActualType(expression);
    String _string = expression.toString();
    Assert.assertNotNull(_string, type);
    String _string_1 = expression.toString();
    String _plus = (_string_1 + " / ");
    String _plus_1 = (_plus + type);
    String _identifier = type.getIdentifier();
    Assert.assertNotNull(_plus_1, _identifier);
  }
  
  public void assertIdentifiableTypeIsResolved(final JvmIdentifiableElement identifiable, final IResolvedTypes types) {
    final JvmTypeReference type = types.getActualType(identifiable);
    String _string = identifiable.toString();
    Assert.assertNotNull(_string, type);
    String _string_1 = identifiable.toString();
    String _plus = (_string_1 + " / ");
    String _plus_1 = (_plus + type);
    String _identifier = type.getIdentifier();
    Assert.assertNotNull(_plus_1, _identifier);
  }
  
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
  public IBatchTypeResolver getTypeResolver() {
    return this.typeResolver;
  }
Solution content 
    }
  }
  
  public void assertExpressionTypeIsResolved(final XExpression expression, final IResolvedTypes types) {
    final JvmTypeReference type = types.getActualType(expression);
    String _string = expression.toString();
    Assert.assertNotNull(_string, type);
    String _string_1 = expression.toString();
    String _plus = (_string_1 + " / ");
    String _plus_1 = (_plus + type);
    String _identifier = type.getIdentifier();
    Assert.assertNotNull(_plus_1, _identifier);
  }
  
  public void assertIdentifiableTypeIsResolved(final JvmIdentifiableElement identifiable, final IResolvedTypes types) {
    final JvmTypeReference type = types.getActualType(identifiable);
    String _string = identifiable.toString();
    Assert.assertNotNull(_string, type);
    String _string_1 = identifiable.toString();
    String _plus = (_string_1 + " / ");
    String _plus_1 = (_plus + type);
    String _identifier = type.getIdentifier();
    Assert.assertNotNull(_plus_1, _identifier);
  }
  
  public IBatchTypeResolver getTypeResolver() {
    return this.typeResolver;
  }
File
BatchTypeResolverTest.java
Developer's decision
Version 2
Kind of conflict
Method declaration
Chunk
Conflicting content 
  }
  
  @Test
<<<<<<< HEAD
=======
  public void testFeatureCall_26() throws Exception {
    this.resolvesTo("{ val list = newArrayList(if (false) new Double(\'-20\') else new Integer(\'20\')).map(v|v.intValue)\n           val Object o = list.head \n           list\n        }", "List");
  }
  
  @Test
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
  public void testToList_01() throws Exception {
    this.resolvesTo("{ val Iterable iter = null org::eclipse::xtext::xbase::tests::typesystem::TypeResolutionTestData::fixedToList(iter) }", "List");
  }
Solution content 
  }
  
  @Test
  public void testFeatureCall_26() throws Exception {
    this.resolvesTo("{ val list = newArrayList(if (false) new Double(\'-20\') else new Integer(\'20\')).map(v|v.intValue)\n           val Object o = list.head \n           list\n        }", "List");
  }
  
  @Test
  public void testToList_01() throws Exception {
    this.resolvesTo("{ val Iterable iter = null org::eclipse::xtext::xbase::tests::typesystem::TypeResolutionTestData::fixedToList(iter) }", "List");
  }
File
BatchTypeResolverTest.java
Developer's decision
Version 2
Kind of conflict
Annotation
Method declaration
Chunk
Conflicting content 
  }
  
  @Test
<<<<<<< HEAD
  public void testDeferredTypeArgumentResolution_05() throws Exception {
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\torg::eclipse::xtext::xbase::lib::CollectionExtensions::addAll(list, null as java.util.ArrayList)\n\t\t\tlist\n\t\t}", "ArrayList");
  }
  
  @Test
  public void testDeferredTypeArgumentResolution_05b() throws Exception {
=======
  public void testDeferredTypeArgumentResolution_005() throws Exception {
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\t$$CollectionExtensions::addAll(list, null as java.util.ArrayList)\n\t\t\tlist\n\t\t}", "ArrayList");
  }
  
  @Test
  public void testDeferredTypeArgumentResolution_006() throws Exception {
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\t$$CollectionExtensions::addAll(list, \'\', \'\')\n\t\t\tlist\n\t\t}", "ArrayList");
  }
  
  @Test
  public void testDeferredTypeArgumentResolution_007() throws Exception {
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\tlist.addAll(null as java.util.ArrayList)\n\t\t\tlist\n\t\t}", "ArrayList");
  }
Solution content 
  }
  
  @Test
  public void testDeferredTypeArgumentResolution_005() throws Exception {
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\t$$CollectionExtensions::addAll(list, null as java.util.ArrayList)\n\t\t\tlist\n\t\t}", "ArrayList");
  }
  
  @Test
  public void testDeferredTypeArgumentResolution_006() throws Exception {
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\t$$CollectionExtensions::addAll(list, \'\', \'\')\n\t\t\tlist\n\t\t}", "ArrayList");
  }
  
  @Test
  public void testDeferredTypeArgumentResolution_007() throws Exception {
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\tlist.addAll(null as java.util.ArrayList)\n\t\t\tlist\n\t\t}", "ArrayList");
  }
File
BatchTypeResolverTest.java
Developer's decision
Version 2
Kind of conflict
Annotation
Method declaration
Method signature
Chunk
Conflicting content 
  }
  
  @Test
<<<<<<< HEAD
  public void testDeferredTypeArgumentResolution_05c() throws Exception {
=======
  public void testDeferredTypeArgumentResolution_008() throws Exception {
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\tlist.addAll(newArrayList(\'\'))\n\t\t\tlist\n\t\t}", "ArrayList");
  }
Solution content 
  }
  
  @Test
  public void testDeferredTypeArgumentResolution_008() throws Exception {
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\tlist.addAll(newArrayList(\'\'))\n\t\t\tlist\n\t\t}", "ArrayList");
  }
File
BatchTypeResolverTest.java
Developer's decision
Version 2
Kind of conflict
Method signature
Chunk
Conflicting content 
  }
  
  @Test
<<<<<<< HEAD
  public void testDeferredTypeArgumentResolution_05d() throws Exception {
=======
  public void testDeferredTypeArgumentResolution_009() throws Exception {
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\tlist.addAll(newHashSet(\'\'))\n\t\t\tlist\n\t\t}", "ArrayList");
  }
Solution content 
  }
  
  }
  
  @Test
  public void testDeferredTypeArgumentResolution_009() throws Exception {
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\tlist.addAll(newHashSet(\'\'))\n\t\t\tlist\n\t\t}", "ArrayList");
File
BatchTypeResolverTest.java
Developer's decision
Version 2
Kind of conflict
Method signature
Chunk
Conflicting content 
  }
  
  @Test
<<<<<<< HEAD
  public void testDeferredTypeArgumentResolution_05e() throws Exception {
=======
  public void testDeferredTypeArgumentResolution_010() throws Exception {
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\tlist.addAll(null as java.util.Collection)\n\t\t\tlist\n\t\t}", "ArrayList");
  }
Solution content 
  }
  
  @Test
  public void testDeferredTypeArgumentResolution_010() throws Exception {
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\tlist.addAll(null as java.util.Collection)\n\t\t\tlist\n\t\t}", "ArrayList");
  }
File
BatchTypeResolverTest.java
Developer's decision
Version 2
Kind of conflict
Method signature
Chunk
Conflicting content 
  }
  
  @Test
<<<<<<< HEAD
  public void testDeferredTypeArgumentResolution_06() throws Exception {
=======
  public void testDeferredTypeArgumentResolution_011() throws Exception {
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\tlist.addAll(\'\', \'\', \'\')\n\t\t\tlist\n\t\t}", "ArrayList");
  }
  
  @Test
  public void testDeferredTypeArgumentResolution_012() throws Exception {
>>>>>>> 61b9355552cfc86446de182703983a1fae2930ec
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\tval secondList = newArrayList\n\t\t\tlist.add(\'\')\n\t\t\tlist.addAll(secondList)\n\t\t\tsecondList\n\t\t}", "ArrayList");
  }
Solution content 
  }
  
  @Test
  public void testDeferredTypeArgumentResolution_011() throws Exception {
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\tlist.addAll(\'\', \'\', \'\')\n\t\t\tlist\n\t\t}", "ArrayList");
  }
  
  @Test
  public void testDeferredTypeArgumentResolution_012() throws Exception {
    this.resolvesTo("{\n\t\t\tval list = newArrayList\n\t\t\tval secondList = newArrayList\n\t\t\tlist.add(\'\')\n\t\t\tlist.addAll(secondList)\n\t\t\tsecondList\n\t\t}", "ArrayList");
  }
File
BatchTypeResolverTest.java
Developer's decision
Version 2
Kind of conflict
Annotation
Method declaration
Method signature