[479826] Completion proposals should inform about replacement info

Bug: 479826
Change-Id: I0161406e9dbb7076f2fea703e6bf00b0abb801fa

5 files changed, 386 insertions, 46 deletions

diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/ICompletionResult.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/ICompletionResult.java
index c0eb2c123..1625ef9f3 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/ICompletionResult.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/ICompletionResult.java
@@ -66,4 +66,36 @@ public interface ICompletionResult {
 	 *            the remaining of identifier part after the cursor
 	 */
 	void setRemaining(String remaining);
+
+	/**
+	 * Returns the offset at which this completion proposal should start replacing existing text.
+	 * 
+	 * @return The offset at which this completion proposal should start replacing existing text.
+	 */
+	int getReplacementOffset();
+
+	/**
+	 * Sets the offset at which this completion proposal should start replacing existing text.
+	 * 
+	 * @param offset
+	 *            The offset at which this completion proposal should start replacing existing text.
+	 */
+	void setReplacementOffset(int offset);
+
+	/**
+	 * If this proposal is going to replace text when accepted, this will return the number of characters
+	 * to replace.
+	 * 
+	 * @return Number of characters to replace from the existing text starting at
+	 *         {@link #getReplacementOffset()}.
+	 */
+	int getReplacementLength();
+
+	/**
+	 * Sets the number of characters to replace with this proposal.
+	 * 
+	 * @param replacementLength
+	 *            The number of characters to replace with this proposal.
+	 */
+	void setReplacementLength(int replacementLength);
 }
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/BasicFilter.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/BasicFilter.java
index 664deb24a..e0b999785 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/BasicFilter.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/BasicFilter.java
@@ -13,6 +13,7 @@ package org.eclipse.acceleo.query.runtime.impl;
 import org.eclipse.acceleo.query.runtime.ICompletionProposal;
 import org.eclipse.acceleo.query.runtime.ICompletionResult;
 import org.eclipse.acceleo.query.runtime.IProposalFilter;
+import org.eclipse.acceleo.query.runtime.impl.completion.EClassifierCompletionProposal;
 
 /**
  * {@link BasicFilter} filters on prefix and remaining.
@@ -20,7 +21,6 @@ import org.eclipse.acceleo.query.runtime.IProposalFilter;
  * @author <a href="mailto:yvan.lussaud@obeo.fr">Yvan Lussaud</a>
  */
 public class BasicFilter implements IProposalFilter {
-
 	/**
 	 * The {@link ICompletionResult}.
 	 */
@@ -43,26 +43,30 @@ public class BasicFilter implements IProposalFilter {
 	 */
 	@Override
 	public boolean keepProposal(ICompletionProposal proposal) {
-		final String name = proposal.getProposal();
 		String prefix = completionResult.getPrefix();
 		if (prefix == null) {
 			return true;
 		}
-	
-		boolean result = false;
-		if (name.substring(0, prefix.length()).equalsIgnoreCase(prefix)) {
-			String remaining = completionResult.getRemaining();
-			if (remaining == null) {
-			remaining = "";
-			}
-			if (remaining != null && remaining.length() != 0) {
-			result = name.lastIndexOf(remaining) >= prefix.length();
-			} else {
-			result = true;
-			}
+
+		String candidateName = proposal.getProposal();
+		if (proposal instanceof EClassifierCompletionProposal) {
+			candidateName = ((EClassifierCompletionProposal)proposal).getObject().getName();
 		}
 
-		return result;
+		return startsWithIgnoreCase(candidateName, prefix);
 	}
 
+	/**
+	 * Checks if the given candidate String starts with the given prefix, ignoring case.
+	 * 
+	 * @param candidate
+	 *            The candidate string.
+	 * @param prefix
+	 *            The expected prefix of {@code candidate}.
+	 * @return <code>true</code> if the given {@code candidate} starts with the given {@code prefix}, ignoring
+	 *         case.
+	 */
+	private static boolean startsWithIgnoreCase(String candidate, String prefix) {
+		return candidate != null && candidate.regionMatches(true, 0, prefix, 0, prefix.length());
+	}
 }
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/CompletionResult.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/CompletionResult.java
index ceaef2828..078980d96 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/CompletionResult.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/CompletionResult.java
@@ -43,6 +43,12 @@ public class CompletionResult implements ICompletionResult {
 	 */
 	private String remaining;
 
+	/** The offset at which this completion proposal should start replacing existing text. */
+	private int replacementOffset;
+
+	/** Number of characters to replace from the existing text starting at{@link #replacementOffset}. */
+	private int replacementLength;
+
 	/**
 	 * Constructor.
 	 * 
@@ -121,4 +127,43 @@ public class CompletionResult implements ICompletionResult {
 		this.remaining = remaining;
 	}
 
+	/**
+	 * {@inheritDoc}
+	 *
+	 * @see org.eclipse.acceleo.query.runtime.ICompletionResult#getReplacementLength()
+	 */
+	@Override
+	public int getReplacementLength() {
+		return replacementLength;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * @see org.eclipse.acceleo.query.runtime.ICompletionResult#getReplacementOffset()
+	 */
+	@Override
+	public int getReplacementOffset() {
+		return replacementOffset;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * @see org.eclipse.acceleo.query.runtime.ICompletionResult#setReplacementLength(int)
+	 */
+	@Override
+	public void setReplacementLength(int replacementLength) {
+		this.replacementLength = replacementLength;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * @see org.eclipse.acceleo.query.runtime.ICompletionResult#setReplacementOffset(int)
+	 */
+	@Override
+	public void setReplacementOffset(int offset) {
+		this.replacementOffset = offset;
+	}
 }
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/QueryCompletionEngine.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/QueryCompletionEngine.java
index 1d958ae90..f58f4e432 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/QueryCompletionEngine.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/QueryCompletionEngine.java
@@ -12,9 +12,14 @@ package org.eclipse.acceleo.query.runtime.impl;
 
 import com.google.common.collect.Sets;
 
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+import org.eclipse.acceleo.query.ast.Error;
+import org.eclipse.acceleo.query.ast.ErrorEnumLiteral;
+import org.eclipse.acceleo.query.ast.ErrorTypeLiteral;
+import org.eclipse.acceleo.query.ast.Expression;
 import org.eclipse.acceleo.query.parser.AstCompletor;
 import org.eclipse.acceleo.query.runtime.ICompletionResult;
 import org.eclipse.acceleo.query.runtime.IQueryCompletionEngine;
@@ -74,6 +79,34 @@ public class QueryCompletionEngine implements IQueryCompletionEngine {
 		result.setPrefix(prefix);
 		result.setRemaining(remaining);
 
+		int replacementLength = 0;
+		int replacementOffset = 0;
+		if (toParse != null) {
+			replacementOffset = toParse.length();
+		}
+
+		// Errors on types or enum literals must be handled differently
+		List<Error> errors = validationResult.getAstResult().getErrors();
+		for (Error error : errors) {
+			if (error instanceof ErrorTypeLiteral || error instanceof ErrorEnumLiteral) {
+				int errorStart = validationResult.getAstResult().getStartPosition((Expression)error);
+				int errorEnd = validationResult.getAstResult().getEndPosition((Expression)error);
+				if (errorStart <= offset - prefix.length() && offset - prefix.length() <= errorEnd) {
+					replacementOffset = validationResult.getAstResult().getStartPosition((Expression)error);
+					replacementLength = validationResult.getAstResult().getEndPosition((Expression)error)
+							- replacementOffset;
+					break;
+				}
+			}
+		}
+
+		// The prefix part is to be replaced in all cases
+		if (prefix != null) {
+			replacementLength += prefix.length();
+		}
+		result.setReplacementOffset(replacementOffset);
+		result.setReplacementLength(replacementLength);
+
 		return result;
 	}
 
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionTest.java
index 59b222d54..82e274d6d 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionTest.java
@@ -84,6 +84,8 @@ public class CompletionTest {
 		assertEquals("", completionResult.getRemaining());
 		assertNoVariableCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(0, completionResult.getReplacementOffset());
+		assertEquals(6, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -95,6 +97,8 @@ public class CompletionTest {
 		assertEquals("", completionResult.getRemaining());
 		assertNoVariableCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(0, completionResult.getReplacementOffset());
+		assertEquals(14, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -106,18 +110,18 @@ public class CompletionTest {
 		assertEquals(null, completionResult.getRemaining());
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(0, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void negativeOffsetTest() {
-		final ICompletionResult completionResult = engine.getCompletion("aa", -1, variableTypes);
-		assertEquals(0, completionResult.getProposals(new BasicFilter(completionResult)).size());
+		engine.getCompletion("aa", -1, variableTypes);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void outOffsetTest() {
-		final ICompletionResult completionResult = engine.getCompletion("aa", 10, variableTypes);
-		assertEquals(0, completionResult.getProposals(new BasicFilter(completionResult)).size());
+		engine.getCompletion("aa", 10, variableTypes);
 	}
 
 	@Test
@@ -129,6 +133,8 @@ public class CompletionTest {
 		assertEquals("", completionResult.getRemaining());
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(0, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -141,6 +147,8 @@ public class CompletionTest {
 		assertNoVariableCompletionProposal(completionResult);
 		assertApplyOn(completionResult, queryEnvironment, EcorePackage.eINSTANCE.getEClass());
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(5, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -153,6 +161,8 @@ public class CompletionTest {
 		assertNoVariableCompletionProposal(completionResult);
 		assertApplyOn(completionResult, queryEnvironment, EcorePackage.eINSTANCE.getEClass());
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(5, completionResult.getReplacementOffset());
+		assertEquals(2, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -165,6 +175,22 @@ public class CompletionTest {
 		assertNoVariableCompletionProposal(completionResult);
 		assertApplyOn(completionResult, queryEnvironment, EcorePackage.eINSTANCE.getEClass());
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(5, completionResult.getReplacementOffset());
+		assertEquals(2, completionResult.getReplacementLength());
+	}
+
+	@Test
+	public void navigationSegmentPrefixLongExpressionRemainingTest() {
+		final ICompletionResult completionResult = engine.getCompletion("self.nam.size()", 7, variableTypes);
+
+		assertEquals("na", completionResult.getPrefix());
+		assertEquals("m", completionResult.getRemaining());
+		assertEquals(1, completionResult.getProposals(new BasicFilter(completionResult)).size());
+		assertNoVariableCompletionProposal(completionResult);
+		assertApplyOn(completionResult, queryEnvironment, EcorePackage.eINSTANCE.getEClass());
+		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(5, completionResult.getReplacementOffset());
+		assertEquals(2, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -178,11 +204,12 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoEOperationCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(5, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
 	public void someIntTest() {
-		// FIXME also test without this registration and ensure it fails
 		queryEnvironment.registerEPackage(EcorePackage.eINSTANCE);
 		final Set<IType> someIntTypes = new LinkedHashSet<IType>();
 		someIntTypes.add(new EClassifierType(queryEnvironment, EcorePackage.eINSTANCE.getEInt()));
@@ -196,6 +223,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoEOperationCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(8, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -212,6 +241,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoEOperationCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(10, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -225,6 +256,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoEOperationCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(4, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -236,6 +269,8 @@ public class CompletionTest {
 		assertEquals(73, completionResult.getProposals(new BasicFilter(completionResult)).size());
 		assertNoVariableCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(5, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -249,16 +284,18 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoEOperationCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(6, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
+	/**
+	 * Checks that the completion includes proposals for the implicit collect (i.e. "aSequence.name" which is
+	 * the equivalent of "aSequence->collect(name)").
+	 */
 	@Test
-	public void testCollectionImplicitCollect() {
+	public void testImplicitCollectProposalsOnDot() {
 		final ICompletionResult dotCompletionResult = engine.getCompletion("Sequence{self}.", 15,
 				variableTypes);
-		final ICompletionResult nothingCompletionResult = engine.getCompletion("Sequence{self}", 14,
-				variableTypes);
-		final ICompletionResult arrowCompletionResult = engine.getCompletion("Sequence{self}->", 16,
-				variableTypes);
 
 		List<ICompletionProposal> dotCompletionProposals = dotCompletionResult.getProposals(new BasicFilter(
 				dotCompletionResult));
@@ -276,21 +313,14 @@ public class CompletionTest {
 		assertTrue(dotProposals.contains("oclIsKindOf()"));
 		assertTrue(!dotProposals.contains("size()"));
 
-		List<ICompletionProposal> nothingCompletionProposals = nothingCompletionResult
-				.getProposals(new BasicFilter(nothingCompletionResult));
-		assertEquals("", nothingCompletionResult.getPrefix());
-		assertEquals("", nothingCompletionResult.getRemaining());
-		assertEquals(4, nothingCompletionProposals.size());
-
-		List<String> nothingProposals = new ArrayList<String>();
-		for (ICompletionProposal nothingCompletionProposal : nothingCompletionProposals) {
-			nothingProposals.add(nothingCompletionProposal.getProposal());
-		}
+		assertEquals(15, dotCompletionResult.getReplacementOffset());
+		assertEquals(0, dotCompletionResult.getReplacementLength());
+	}
 
-		assertTrue(nothingProposals.contains("+ "));
-		assertTrue(nothingProposals.contains("- "));
-		assertTrue(nothingProposals.contains("= "));
-		assertTrue(nothingProposals.contains("<> "));
+	@Test
+	public void testImplicitCollectProposalsOnArrow() {
+		final ICompletionResult arrowCompletionResult = engine.getCompletion("Sequence{self}->", 16,
+				variableTypes);
 
 		List<ICompletionProposal> arrowCompletionProposals = arrowCompletionResult
 				.getProposals(new BasicFilter(arrowCompletionResult));
@@ -308,6 +338,33 @@ public class CompletionTest {
 		assertTrue(arrowProposals.contains("collect()"));
 		assertTrue(!arrowProposals.contains("name"));
 
+		assertEquals(16, arrowCompletionResult.getReplacementOffset());
+		assertEquals(0, arrowCompletionResult.getReplacementLength());
+	}
+
+	@Test
+	public void testImplicitCollectProposalsNoSeparator() {
+		final ICompletionResult noSeparatorCompletionResult = engine.getCompletion("Sequence{self}", 14,
+				variableTypes);
+
+		List<ICompletionProposal> nothingCompletionProposals = noSeparatorCompletionResult
+				.getProposals(new BasicFilter(noSeparatorCompletionResult));
+		assertEquals("", noSeparatorCompletionResult.getPrefix());
+		assertEquals("", noSeparatorCompletionResult.getRemaining());
+		assertEquals(4, nothingCompletionProposals.size());
+
+		List<String> nothingProposals = new ArrayList<String>();
+		for (ICompletionProposal nothingCompletionProposal : nothingCompletionProposals) {
+			nothingProposals.add(nothingCompletionProposal.getProposal());
+		}
+
+		assertTrue(nothingProposals.contains("+ "));
+		assertTrue(nothingProposals.contains("- "));
+		assertTrue(nothingProposals.contains("= "));
+		assertTrue(nothingProposals.contains("<> "));
+
+		assertEquals(14, noSeparatorCompletionResult.getReplacementOffset());
+		assertEquals(0, noSeparatorCompletionResult.getReplacementLength());
 	}
 
 	@Test
@@ -322,6 +379,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoEOperationCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(0, completionResult.getReplacementOffset());
+		assertEquals(7, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -332,6 +391,8 @@ public class CompletionTest {
 		assertEquals("", completionResult.getRemaining());
 		assertEquals(0, completionResult.getProposals(new BasicFilter(completionResult)).size());
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(0, completionResult.getReplacementOffset());
+		assertEquals(15, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -346,6 +407,8 @@ public class CompletionTest {
 		assertEquals(true, proposal instanceof VariableDeclarationCompletionProposal);
 		assertEquals("myEClass | ", proposal.getProposal());
 		assertEquals("myEClass | ".length(), proposal.getCursorOffset());
+		assertEquals(13, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -361,6 +424,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoEOperationCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(17, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -376,6 +441,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoEOperationCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(20, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -394,6 +461,8 @@ public class CompletionTest {
 			}
 		}
 		assertTrue(found);
+		assertEquals(0, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -406,6 +475,8 @@ public class CompletionTest {
 		ICompletionProposal proposal = completionResult.getProposals(new BasicFilter(completionResult))
 				.get(0);
 		assertEquals("let ", proposal.getProposal());
+		assertEquals(0, completionResult.getReplacementOffset());
+		assertEquals(2, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -415,6 +486,8 @@ public class CompletionTest {
 		assertEquals("", completionResult.getPrefix());
 		assertEquals("", completionResult.getRemaining());
 		assertEquals(0, completionResult.getProposals(new BasicFilter(completionResult)).size());
+		assertEquals(4, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -424,6 +497,8 @@ public class CompletionTest {
 		assertEquals("", completionResult.getPrefix());
 		assertEquals("", completionResult.getRemaining());
 		assertEquals(2, completionResult.getProposals(new BasicFilter(completionResult)).size());
+		assertEquals(6, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -435,6 +510,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoEOperationCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(8, completionResult.getReplacementOffset());
+		assertEquals(7, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -446,6 +523,8 @@ public class CompletionTest {
 		ICompletionProposal proposal = completionResult.getProposals(new BasicFilter(completionResult))
 				.get(0);
 		assertEquals(" = ", proposal.getProposal());
+		assertEquals(22, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -453,6 +532,8 @@ public class CompletionTest {
 		final ICompletionResult completionResult = engine.getCompletion("let a = ", 8, variableTypes);
 		assertEquals(TOTAL_NUMBER_OF_PROPOSAL, completionResult.getProposals(
 				new BasicFilter(completionResult)).size());
+		assertEquals(8, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -461,6 +542,8 @@ public class CompletionTest {
 
 		assertEquals(TOTAL_NUMBER_OF_PROPOSAL, completionResult.getProposals(
 				new BasicFilter(completionResult)).size());
+		assertEquals(11, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	public void testConditionalIfCompletionFromNothing() {
@@ -478,6 +561,8 @@ public class CompletionTest {
 			}
 		}
 		assertTrue(found);
+		assertEquals(0, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -490,6 +575,8 @@ public class CompletionTest {
 		ICompletionProposal proposal = completionResult.getProposals(new BasicFilter(completionResult))
 				.get(0);
 		assertEquals("if ", proposal.getProposal());
+		assertEquals(0, completionResult.getReplacementOffset());
+		assertEquals(1, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -503,6 +590,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoEOperationCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
+		assertEquals(3, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -514,6 +603,8 @@ public class CompletionTest {
 		assertEquals(1, completionResult.getProposals(new BasicFilter(completionResult)).size());
 		assertEquals("then ", completionResult.getProposals(new BasicFilter(completionResult)).get(0)
 				.getProposal());
+		assertEquals(8, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	/**
@@ -530,6 +621,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoEOperationCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
+		assertEquals(13, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -542,6 +635,21 @@ public class CompletionTest {
 		assertEquals(1, completionResult.getProposals(new BasicFilter(completionResult)).size());
 		assertEquals("else ", completionResult.getProposals(new BasicFilter(completionResult)).get(0)
 				.getProposal());
+		assertEquals(18, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
+	}
+
+	@Test
+	public void testConditionWithinTrueBranchCompletion() {
+		final ICompletionResult completionResult = engine.getCompletion("if true then tr", 15, variableTypes);
+
+		assertEquals("tr", completionResult.getPrefix());
+		assertEquals("", completionResult.getRemaining());
+		assertEquals(1, completionResult.getProposals(new BasicFilter(completionResult)).size());
+		assertEquals("true", completionResult.getProposals(new BasicFilter(completionResult)).get(0)
+				.getProposal());
+		assertEquals(13, completionResult.getReplacementOffset());
+		assertEquals(2, completionResult.getReplacementLength());
 	}
 
 	/**
@@ -559,6 +667,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoEOperationCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
+		assertEquals(23, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -571,6 +681,8 @@ public class CompletionTest {
 		assertEquals(1, completionResult.getProposals(new BasicFilter(completionResult)).size());
 		assertEquals("endif ", completionResult.getProposals(new BasicFilter(completionResult)).get(0)
 				.getProposal());
+		assertEquals(29, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	/**
@@ -587,6 +699,8 @@ public class CompletionTest {
 		assertNoVariableCompletionProposal(completionResult);
 		assertApplyOn(completionResult, queryEnvironment, EcorePackage.eINSTANCE.getEClass());
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(35, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	/**
@@ -602,6 +716,8 @@ public class CompletionTest {
 		assertEquals("", completionResult.getRemaining());
 		assertNoVariableCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(36, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	/**
@@ -618,6 +734,8 @@ public class CompletionTest {
 		assertNoVariableCompletionProposal(completionResult);
 		assertApplyOn(completionResult, queryEnvironment, EcorePackage.eINSTANCE.getEClass());
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(65, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	/**
@@ -633,22 +751,55 @@ public class CompletionTest {
 		assertEquals("", completionResult.getRemaining());
 		assertNoVariableCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(66, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
-	public void test472179TypeLiteralComletion() {
+	public void test472179TypeLiteralCompletion() {
 		final ICompletionResult completionResult = engine.getCompletion("self.eContainer(ecore::EP)", 25,
 				variableTypes);
 
-		assertEquals(0, completionResult.getProposals(new BasicFilter(completionResult)).size());
+		assertEquals(2, completionResult.getProposals(new BasicFilter(completionResult)).size());
 		assertEquals("EP", completionResult.getPrefix());
 		assertEquals("", completionResult.getRemaining());
 		assertNoVariableCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(16, completionResult.getReplacementOffset());
+		assertEquals(9, completionResult.getReplacementLength());
 	}
 
 	@Test
-	public void test471583TypeLiteralComletion() {
+	public void testTypeLiteralCompletionWithPrefix() {
+		final ICompletionResult completionResult = engine.getCompletion("self.eContainer(ecore::EPack)", 28,
+				variableTypes);
+
+		assertEquals(1, completionResult.getProposals(new BasicFilter(completionResult)).size());
+		assertEquals("EPack", completionResult.getPrefix());
+		assertEquals("", completionResult.getRemaining());
+		assertNoVariableCompletionProposal(completionResult);
+		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(16, completionResult.getReplacementOffset());
+		assertEquals(12, completionResult.getReplacementLength());
+	}
+
+	@Test
+	public void testTypeLiteralCompletionWithPrefixAndRemaining() {
+		final ICompletionResult completionResult = engine.getCompletion("self.eContainer(ecore::EPack)", 26,
+				variableTypes);
+
+		assertEquals(2, completionResult.getProposals(new BasicFilter(completionResult)).size());
+		assertEquals("EPa", completionResult.getPrefix());
+		assertEquals("ck", completionResult.getRemaining());
+		assertNoVariableCompletionProposal(completionResult);
+		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(16, completionResult.getReplacementOffset());
+		// the "remaining" ck are not part of the replacement
+		assertEquals(10, completionResult.getReplacementLength());
+	}
+
+	@Test
+	public void test471583TypeLiteralCompletion() {
 		final ICompletionResult completionResult = engine.getCompletion(
 				"self->eClassifiers->filter(ecore::)", 34, variableTypes);
 
@@ -657,6 +808,8 @@ public class CompletionTest {
 		assertEquals("", completionResult.getRemaining());
 		assertNoVariableCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(27, completionResult.getReplacementOffset());
+		assertEquals(7, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -675,6 +828,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
+		assertEquals(14, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -693,6 +848,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
+		assertEquals(14, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -712,6 +869,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
+		assertEquals(14, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -730,6 +889,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
+		assertEquals(14, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -748,6 +909,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
+		assertEquals(13, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -766,6 +929,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
+		assertEquals(13, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -785,6 +950,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
+		assertEquals(13, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -803,6 +970,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
+		assertEquals(13, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -821,6 +990,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
+		assertEquals(13, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -839,6 +1010,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
+		assertEquals(13, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -858,6 +1031,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
+		assertEquals(13, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -876,6 +1051,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
+		assertEquals(13, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -890,6 +1067,8 @@ public class CompletionTest {
 		assertEquals(0, completionResult.getProposals(new BasicFilter(completionResult)).size());
 		assertEquals("", completionResult.getPrefix());
 		assertEquals("", completionResult.getRemaining());
+		assertEquals(8, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -904,6 +1083,11 @@ public class CompletionTest {
 		assertEquals(0, completionResult.getProposals(new BasicFilter(completionResult)).size());
 		assertEquals("te", completionResult.getPrefix());
 		assertEquals("st", completionResult.getRemaining());
+
+		// This would replace part of the string...
+		// but makes no sense as there is no completion within string literals
+		assertEquals(8, completionResult.getReplacementOffset());
+		assertEquals(2, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -918,6 +1102,8 @@ public class CompletionTest {
 		assertEquals(2, completionResult.getProposals(new BasicFilter(completionResult)).size());
 		assertEquals("", completionResult.getPrefix());
 		assertEquals("", completionResult.getRemaining());
+		assertEquals(15, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -936,6 +1122,8 @@ public class CompletionTest {
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoServiceCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
+		assertEquals(16, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -951,34 +1139,56 @@ public class CompletionTest {
 		assertEquals(1, completionResult.getProposals(new BasicFilter(completionResult)).size());
 		assertEquals("", completionResult.getPrefix());
 		assertEquals("", completionResult.getRemaining());
+		assertEquals(31, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
+	}
+
+	@Test
+	public void testOrderedSetMinus() {
+		final Map<String, Set<IType>> types = new LinkedHashMap<String, Set<IType>>();
+
+		final ICompletionResult completionResult = engine.getCompletion("OrderedSet{}-", 13, types);
+
+		assertEquals(128, completionResult.getProposals(new BasicFilter(completionResult)).size());
+		assertEquals("", completionResult.getPrefix());
+		assertEquals("", completionResult.getRemaining());
+		assertNoEOperationCompletionProposal(completionResult);
+		assertNoVariableCompletionProposal(completionResult);
+		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(13, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
 	public void test480853EmptyOrderedSetLiteralInExtension() {
 		final Map<String, Set<IType>> types = new LinkedHashMap<String, Set<IType>>();
 
-		final ICompletionResult completionResult = engine.getCompletion("OrderedSet()->", 13, types);
+		final ICompletionResult completionResult = engine.getCompletion("OrderedSet{}->", 14, types);
 
-		assertEquals(117, completionResult.getProposals(new BasicFilter(completionResult)).size());
+		assertEquals(56, completionResult.getProposals(new BasicFilter(completionResult)).size());
 		assertEquals("", completionResult.getPrefix());
 		assertEquals("", completionResult.getRemaining());
 		assertNoEOperationCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(14, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
 	public void test480853EmptySequenceLiteralInExtension() {
 		final Map<String, Set<IType>> types = new LinkedHashMap<String, Set<IType>>();
 
-		final ICompletionResult completionResult = engine.getCompletion("Sequence()->", 12, types);
+		final ICompletionResult completionResult = engine.getCompletion("Sequence{}->", 12, types);
 
-		assertEquals(117, completionResult.getProposals(new BasicFilter(completionResult)).size());
+		assertEquals(56, completionResult.getProposals(new BasicFilter(completionResult)).size());
 		assertEquals("", completionResult.getPrefix());
 		assertEquals("", completionResult.getRemaining());
 		assertNoEOperationCompletionProposal(completionResult);
 		assertNoVariableCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(12, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	public void testTypeLiteralInTypeSetLiteral() {
@@ -989,6 +1199,8 @@ public class CompletionTest {
 		assertEquals("", completionResult.getRemaining());
 		assertNoVariableCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(1, completionResult.getReplacementOffset());
+		assertEquals(7, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -1000,6 +1212,8 @@ public class CompletionTest {
 		assertEquals("", completionResult.getRemaining());
 		assertNoVariableCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(1, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -1012,6 +1226,8 @@ public class CompletionTest {
 		assertEquals("", completionResult.getRemaining());
 		assertNoVariableCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(14, completionResult.getReplacementOffset());
+		assertEquals(7, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -1023,6 +1239,8 @@ public class CompletionTest {
 		assertEquals("", completionResult.getRemaining());
 		assertNoVariableCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(14, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -1035,6 +1253,8 @@ public class CompletionTest {
 		assertEquals("", completionResult.getRemaining());
 		assertNoVariableCompletionProposal(completionResult);
 		assertNoVariableDeclarationCompletionProposal(completionResult);
+		assertEquals(16, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -1049,6 +1269,8 @@ public class CompletionTest {
 		assertNoVariableDeclarationCompletionProposal(completionResult);
 		assertNoFeatureCompletionProposal(completionResult);
 		assertNoEOperationCompletionProposal(completionResult);
+		assertEquals(17, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -1063,6 +1285,8 @@ public class CompletionTest {
 		assertEquals(0, completionResult.getProposals(new BasicFilter(completionResult)).size());
 		assertEquals("n", completionResult.getPrefix());
 		assertEquals("", completionResult.getRemaining());
+		assertEquals(2, completionResult.getReplacementOffset());
+		assertEquals(1, completionResult.getReplacementLength());
 	}
 
 	@Test
@@ -1078,6 +1302,8 @@ public class CompletionTest {
 		assertEquals(0, completionResult.getProposals(new BasicFilter(completionResult)).size());
 		assertEquals("", completionResult.getPrefix());
 		assertEquals("", completionResult.getRemaining());
+		assertEquals(31, completionResult.getReplacementOffset());
+		assertEquals(0, completionResult.getReplacementLength());
 	}
 
 	@Test