@Override
	public final ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) {
		resetComputeState();
		
		// The code below has been commented, it causes a bug with templates with "${word_selection} " usage,
		// and it's not clear this functionality made sense in the first place.
		
//		if(viewer instanceof LangSourceViewer) {
//			LangSourceViewer sourceViewer = (LangSourceViewer) viewer;
//			if(sourceViewer.getSelectedRange().y > 0) {
//				// Correct the invocation offset for content assist. 
//				// The issue is that if text is selected, the cursor can either be on the left, or the right
//				// but the offset used will always be the left side of the selection, unless we correct it.
//				
//				int caretOffset = sourceViewer.getTextWidget().getCaretOffset();
//				offset = sourceViewer.widgetOffset2ModelOffset(caretOffset);
//			}
//		}
		
		return doComputeCompletionProposals(viewer, offset);
	}
 

/**
 * The <code>TextOperationAction</code> implementation of this <code>IAction</code> method runs the operation with
 * the current operation code.
 */
@Override
public void run() {
	if (fOperationCode == -1 || fOperationTarget == null)
		return;

	ITextViewer viewer = getTextViewer();
	if (viewer == null)
		return;

	if (!fRunsOnReadOnly && !canModifyViewer())
		return;

	Display display = null;

	Shell shell = viewer.getTextWidget().getShell();
	if (shell != null && !shell.isDisposed())
		display = shell.getDisplay();

	BusyIndicator.showWhile(display, new Runnable() {
		@Override
		public void run() {
			fOperationTarget.doOperation(fOperationCode);
		}
	});
}
 

@Override
public void apply(ITextViewer viewer, char trigger, int stateMask, int offset) {
    IDocument document = viewer.getDocument();
    int finalOffset = applyOnDocument(viewer, document, trigger, stateMask, offset);
    if (finalOffset >= 0) {
        try {
            PySelection ps = new PySelection(document, finalOffset);
            int firstCharPosition = PySelection.getFirstCharPosition(ps.getLine());
            int lineOffset = ps.getLineOffset();
            int location = lineOffset + firstCharPosition;
            int len = finalOffset - location;
            fCursorPosition = location;
            fReplacementLength = len;

        } catch (Exception e) {
            Log.log(e);
        }

    }
}
 

public Indexable<IContextInformation> computeContextInformation(ISourceBufferExt sourceBuffer, 
		ITextViewer viewer, int offset) {
	clearErrorMessage();
	
	ArrayList2<IContextInformation> proposals = new ArrayList2<>();
	
	for (ILangCompletionProposalComputer computer : computers) {
		try {
			Indexable<IContextInformation> computerProposals = computer.computeContextInformation(
				sourceBuffer, viewer, offset);
			if(computerProposals != null) {
				proposals.addAll2(computerProposals);
			}
		} catch(OperationSoftFailure e) {
			updateErrorMessage(e.getMessage());
		}
	}
	return proposals;
}
 

public String getHoverInfo(ITextViewer textViewer, IRegion subject) {
	try {
		IDocument doc= textViewer.getDocument();
		int offset= subject.getOffset();
		if (offset >= 2 && "${".equals(doc.get(offset-2, 2))) { //$NON-NLS-1$
			String varName= doc.get(offset, subject.getLength());
			TemplateContextType contextType= fProcessor.getContextType();
			if (contextType != null) {
				Iterator iter= contextType.resolvers();
				while (iter.hasNext()) {
					TemplateVariableResolver var= (TemplateVariableResolver) iter.next();
					if (varName.equals(var.getType())) {
						return var.getDescription();
					}
				}
			}
		}				
	} catch (BadLocationException e) {
	}
	return null;
}
 

private void validateCompletionProposals(String text, String[] expectedProposalTexts)
		throws IOException, CoreException {
	IProject project = getProject(BASIC_PROJECT_NAME);
	IFile file = project.getFolder("src").getFile("main.rs");
	IEditorPart editor = IDE.openEditor(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(), file);
	((ITextEditor) editor).getDocumentProvider().getDocument(editor.getEditorInput()).set(text);

	ICompletionProposal[] proposals = (new SnippetContentAssistProcessor()).computeCompletionProposals(
			(ITextViewer) editor.getAdapter(ITextOperationTarget.class), text.length() - 1);
	if (expectedProposalTexts == null) {
		assertTrue(proposals == null || proposals.length == 0);
		return;
	}
	assertNotNull(proposals);
	for (int i = 0; i < proposals.length; i++) {
		assertEquals(((LSCompletionProposal) proposals[i]).getItem().getTextEdit().getNewText(),
				expectedProposalTexts[i]);
	}
}
 

@Override
public void apply(final ITextViewer viewer, char trigger, int stateMask, final int offset)
{
	delegateTemplateProposal = null;
	if (contains(triggerChars, trigger))
	{
		if (triggerChar == trigger)
		{
			doApply(viewer, trigger, stateMask, offset);
		}
		else
		{
			delegateTemplateProposal = templateProposals[trigger - '1'];
			((ICompletionProposalExtension2) templateProposals[trigger - '1']).apply(viewer, trigger, stateMask,
					offset);
		}
	}
	else
	{
		doApply(viewer, trigger, stateMask, offset);
	}
}
 

public IRegion getHoverRegion(ITextViewer textViewer, int offset)
{
	IParseNode activeNode = getActiveNode(textViewer, offset);
	if (activeNode instanceof CSSSimpleSelectorNode)
	{
		CSSSimpleSelectorNode node = (CSSSimpleSelectorNode) activeNode;
		// Verify that this is an HTML element selector
		String typeSelector = node.getTypeSelector();
		if (!StringUtil.isEmpty(typeSelector))
		{
			ElementElement element = new HTMLIndexQueryHelper().getElement(typeSelector.toLowerCase());
			if (element != null)
			{
				return new Region(node.getStartingOffset(), node.getLength());
			}
		}
	}

	return null;
}
 

@Override
protected IHyperlink[] doDetect(JsonDocument doc, ITextViewer viewer, HyperlinkInfo info, JsonPointer pointer) {
    Matcher matcher = PATTERN.matcher(pointer.toString());
    String link = matcher.find() ? matcher.group(1) : null;

    if (link != null) {
        Model model = doc.getModel();
        AbstractNode securityScheme = model.find("/components/securitySchemes/" + link);

        if (securityScheme != null) {
            IRegion target = doc.getRegion(securityScheme.getPointer());
            if (target != null) {
                return new IHyperlink[] { new SwaggerHyperlink(info.text, viewer, info.region, target) };
            }
        }
    }
    return null;
}
 

@Override
public IInformationControlCreatorProvider getHoverInfo(final EObject object, final ITextViewer viewer, final IRegion region) {
	return new IInformationControlCreatorProvider2() {

		@Override
		public IInformationControlCreator getHoverControlCreator() {
			return DefaultEObjectHoverProvider.this.getHoverControlCreator();
		}

		@Override
		public Object getInfo() {
			try {
				return getHoverInfo(object, region, null);
			} catch (RuntimeException e) {
				LOG.error("Error on computation of hover information. No hover information available for "+ object + " at " + region, e);
				return null;
			}
		}

		@Override
		public IInformationControlCreator getInformationPresenterControlCreator() {
			return DefaultEObjectHoverProvider.this.getInformationPresenterControlCreator();
		}};
}
 

@Test public void testBug276742_08b() throws Exception {
	String modelAsString = "Foo {}";
	ContentAssistProcessorTestBuilder builder = newBuilder();
	XtextContentAssistProcessor processor = get(XtextContentAssistProcessor.class);
	XtextResource resource = getResourceFromString(modelAsString);

	ITextViewer viewer = builder.getSourceViewer(modelAsString, builder.getDocument(resource, modelAsString));
	ContentAssistContext[] contexts = processor.getContextFactory()
			.create(viewer, modelAsString.length(), resource);
	assertEquals(2, contexts.length);
	Set<EClass> contextTypes = Sets.newHashSet(CrossReferenceProposalTestPackage.Literals.MODEL,
			CrossReferenceProposalTestPackage.Literals.CLASS);
	CrossReferenceProposalTestLanguageGrammarAccess grammarAccess = get(CrossReferenceProposalTestLanguageGrammarAccess.class);
	for (ContentAssistContext context : contexts) {
		EObject model = context.getCurrentModel();
		assertTrue(contextTypes.remove(model.eClass()));
		if (context.getFirstSetGrammarElements().contains(
				grammarAccess.getClassAccess().getRightCurlyBracketKeyword_3())) {
			assertEquals(CrossReferenceProposalTestPackage.Literals.CLASS, model.eClass());
		}
		else {
			assertEquals(CrossReferenceProposalTestPackage.Literals.MODEL, model.eClass());
		}
	}
}
 

@Override
public CompletableFuture<ICodeLens[]> provideCodeLenses(ICodeLensContext context, IProgressMonitor monitor) {
	ITextViewer textViewer = context.getViewer();
	IResource resource = TypeScriptResourceUtil.getFile(textViewer.getDocument());
	if (resource == null) {
		return null;
	}
	if (TypeScriptResourceUtil.canConsumeTsserver(resource)) {
		// the project of the resource has typescript nature, execute
		// typescript
		// navtree.
		try {
			IProject project = resource.getProject();
			IIDETypeScriptProject tsProject = TypeScriptResourceUtil.getTypeScriptProject(project);
			IDocument document = textViewer.getDocument();
			IIDETypeScriptFile tsFile = tsProject.openFile(resource, document);
			return tsProject.getClient().navtree(tsFile.getName(), tsFile).thenApply(tree -> {
				List<Range> referenceableSpans = new ArrayList<>();
				if (tree != null && tree.hasChildItems()) {
					tree.getChildItems().forEach(item -> this.walkNavTree(tsFile, item, null, referenceableSpans));
				}
				return toCodeLenses(referenceableSpans, tsFile);
			});
		} catch (Exception e) {
			TypeScriptUIPlugin.log("Error while TypeScript codelens", e);
		}
	}
	return null;
}
 

@Override
protected CompletableFuture<Void> doResolve(ITextViewer viewer, IProgressMonitor monitor) {
	if (getLabel() != null) {
		return super.doResolve(viewer, monitor);
	}
	return CompletableFuture.runAsync(() -> {
		updateLabel();
	});
}
 

/**
 * Returns the information which should be presented when a hover or persistent popup is shown
 * for the specified hover region.
 * 
 * @param textViewer the viewer on which the hover popup should be shown
 * @param hoverRegion the text range in the viewer which is used to determine the hover display
 *            information
 * @param forInformationProvider <code>true</code> iff the hover info is requested by the
 *            information presenter. In this case, the method only considers text hovers for
 *            which a proper IInformationControlCreator is available that can supply focusable
 *            and resizable information controls.
 * 
 * @return the hover popup display information, or <code>null</code> if none available
 * 
 * @see ITextHoverExtension2#getHoverInfo2(ITextViewer, IRegion)
 * @since 3.8
 */
public Object getHoverInfo2(ITextViewer textViewer, IRegion hoverRegion, boolean forInformationProvider) {

	checkTextHovers();
	fBestHover= null;

	if (fInstantiatedTextHovers == null)
		return null;

	for (Iterator<IJavaEditorTextHover> iterator= fInstantiatedTextHovers.iterator(); iterator.hasNext(); ) {
		ITextHover hover= iterator.next();
		if (hover == null)
			continue;

		if (hover instanceof ITextHoverExtension2) {
			Object info= ((ITextHoverExtension2) hover).getHoverInfo2(textViewer, hoverRegion);
			if (info != null && !(forInformationProvider && getInformationPresenterControlCreator(hover) == null)) {
				fBestHover= hover;
				return info;
			}
		} else {
			String s= hover.getHoverInfo(textViewer, hoverRegion);
			if (s != null && s.trim().length() > 0) {
				fBestHover= hover;
				return s;
			}
		}
	}

	return null;
}
 

public JavaDebugElementCodeMiningASTVisitor(IJavaStackFrame frame, CompilationUnit cu, ITextViewer viewer,
		List<ICodeMining> minings, AbstractDebugVariableCodeMiningProvider provider) {
	this.cu = cu;
	this.minings = minings;
	this.provider = provider;
	this.viewer = viewer;
	this.fFrame = frame;
}
 

@Override
protected List provideCodeMinings(ITextViewer viewer, IJavaStackFrame frame, IProgressMonitor monitor) {
	List<ICodeMining> minings = new ArrayList<>();
	ITextEditor textEditor = super.getAdapter(ITextEditor.class);
	ITypeRoot unit = EditorUtility.getEditorInputJavaElement(textEditor, true);
	if (unit == null) {
		return minings;
	}
	CompilationUnit cu = SharedASTProvider.getAST(unit, SharedASTProvider.WAIT_YES, null);
	JavaDebugElementCodeMiningASTVisitor visitor = new JavaDebugElementCodeMiningASTVisitor(frame, cu, viewer,
			minings, this);
	cu.accept(visitor);
	return minings;
}
 

@Override
public IInformationControlCreatorProvider getHoverInfo(EObject eObject, ITextViewer viewer, IRegion region) {
	if (eObject instanceof JvmIdentifiableElement) {
		JvmIdentifiableElement jvmIdentifiableElement = (JvmIdentifiableElement) eObject;
		IJavaElement javaElement = javaElementFinder.findElementFor(jvmIdentifiableElement);
		if (javaElement!=null && javaElement.exists()) {
			javadocHover.setJavaElement(javaElement);
			final Object hoverInfo2 = javadocHover.getHoverInfo2(viewer, region);
			return new IInformationControlCreatorProvider2() {

				@Override
				public IInformationControlCreator getHoverControlCreator() {
					return javadocHover.getHoverControlCreator();
				}

				@Override
				public Object getInfo() {
					return hoverInfo2;
				}

				@Override
				public IInformationControlCreator getInformationPresenterControlCreator() {
					return javadocHover.getInformationPresenterControlCreator();
				}
				
			};
		}
	} 
	return null;
}
 

@Override
public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) {
	IXtextDocument document = xtextDocumentUtil.getXtextDocument(viewer);
	if (document != null) {
		return document.priorityReadOnly(createCompletionProposalComputer(viewer, offset));
	}
	return new ICompletionProposal[0];
}
 

public CompletionProposalComputer(State state, ITextViewer viewer, int offset) {
	super();
	this.proposals = new LinkedHashSet<ICompletionProposal>(30);
	this.state = state;
	this.viewer = viewer;
	this.offset = offset;
}
 

private static int getCaretOffset(ITextViewer textViewer)
{
	StyledText textWidget = textViewer.getTextWidget();
	int caretOffset = textWidget.getCaretOffset();
	if (textViewer instanceof ITextViewerExtension5)
	{
		ITextViewerExtension5 extension = (ITextViewerExtension5) textViewer;
		return extension.widgetOffset2ModelOffset(caretOffset);
	}
	return caretOffset;
}
 

@Override
public IRegion getHoverRegion(ITextViewer textViewer, int offset) {
	IXtextDocument xtextDocument = xtextDocumentUtil.getXtextDocument(textViewer);
	if(xtextDocument == null || offset<0 || xtextDocument.getLength() < offset) 
		return null;
	@SuppressWarnings("restriction")
	IRegion word = org.eclipse.jdt.internal.ui.text.JavaWordFinder.findWord(xtextDocument, offset);
	if (word!= null)
		return word;
	//TODO return null for non-operators.
	return new Region(offset, 0);
}
 

public IContextInformation[] computeContextInformation(ITextViewer viewer,
		int offset) {

	// FIXME -- for testing
	// Retrieve selected range
	Point selectedRange = viewer.getSelectedRange();
	if (selectedRange.y > 0) {

		if (styleManager == null) {
			styleManager = TexStyleCompletionManager.getInstance();
		}
		return styleManager.getStyleContext();
	}
	return new ContextInformation[0];
}
 

/**
 * TODO: add comment.
 *
 * @param textViewer the text viewer
 * @param offset the offset
 * @return the region
 */
@Override
public IRegion getSubject(ITextViewer textViewer, int offset) {
  Point selection = textViewer.getTextWidget().getSelection();

  int length = selection.y - selection.x;
  return new Region(offset, length);
}
 

public static PyDocumentTemplateContext createContext(final TemplateContextType contextType,
        final ITextViewer viewer, final IRegion region) {
    if (contextType != null) {
        IDocument document = viewer.getDocument();
        PySelection selection = new PySelection(document,
                ((ITextSelection) viewer.getSelectionProvider().getSelection()).getOffset());
        String indent = selection.getIndentationFromLine();
        return PyDocumentTemplateContext.createContext(contextType, viewer, region, indent);
    }
    return null;
}
 

@Override
public ILineDiffer getDocumentLineDiffer(ITextViewer viewer, ITextEditor textEditor) {
	IQuickDiffReferenceProvider provider = new GitQuickDiffProvider();
	DocumentLineDiffer differ = new DocumentLineDiffer();
	differ.setReferenceProvider(provider);
	provider.setActiveEditor(textEditor);
	return differ;
}
 

private void beginCompoundChange(ITextViewer viewer) {
	if (viewer instanceof ITextViewerExtension) {
		ITextViewerExtension extension= (ITextViewerExtension) viewer;
		IRewriteTarget target= extension.getRewriteTarget();
		target.beginCompoundChange();
	}
}
 

@SuppressWarnings("deprecation")
@Override
public Object getHoverInfo(ISourceBuffer sourceBuffer, IRegion hoverRegion, ITextViewer textViewer) {
       
	fDelegate = getDelegate();
       if (fDelegate instanceof ITextHoverExtension2) {
		return ((ITextHoverExtension2) fDelegate).getHoverInfo2(textViewer, hoverRegion);
       }
       // fall back to legacy method
       if (fDelegate != null) {
           return fDelegate.getHoverInfo(textViewer, hoverRegion);
       }
       return null;
   }
 

private List<IContextInformation> collectContextInformation(ITextViewer viewer, int offset, IProgressMonitor monitor) {
	List<IContextInformation> proposals= new ArrayList<IContextInformation>();
	ContentAssistInvocationContext context= createContext(viewer, offset);

	List<CompletionProposalCategory> providers= getCategories();
	for (CompletionProposalCategory cat : providers) {
		List<IContextInformation> computed= cat.computeContextInformation(context, fPartition, new SubProgressMonitor(monitor, 1));
		proposals.addAll(computed);
		if (fErrorMessage == null)
			fErrorMessage= cat.getErrorMessage();
	}

	return proposals;
}
 

public IInformationControlCreatorProvider getInformationControlCreatorProvider(ITextViewer textViewer,
		IRegion hoverRegion) {

	if (!IS_JAVA_DEBUG_HOVER_AVAILABLE)
		return null;

	final JavaDebugHover javaDebugHover = injector.getInstance(JavaDebugHover.class);
	final Object hoverInfo = javaDebugHover.getHoverInfo2(textViewer, hoverRegion);
	if (hoverInfo == null)
		return null;

	return new IEObjectHoverProvider.IInformationControlCreatorProvider2() {
		@Override
		public IInformationControlCreator getHoverControlCreator() {
			return javaDebugHover.getHoverControlCreator();
		}

		@Override
		public Object getInfo() {
			return hoverInfo;
		}

		@Override
		public IInformationControlCreator getInformationPresenterControlCreator() {
			return javaDebugHover.getInformationPresenterControlCreator();
		}
	};
}
 

/**
 * Get the current selection from the given {@code viewer}. If there is a (non
 * empty) selection returns a {@code Range} computed from the selection and
 * returns this wrapped in an optional, otherwise returns an empty optional.
 *
 * @param document currently active document
 * @param viewer   the text viewer for the completion
 * @return either an optional containing the text selection, or an empty
 *         optional, if there is no (non-empty) selection.
 */
private static Optional<Range> getRangeFromSelection(IDocument document, ITextViewer viewer) {
	if (!(viewer instanceof ITextViewerExtension9)) {
		return Optional.empty();
	}
	ITextViewerExtension9 textViewer = (ITextViewerExtension9) viewer;

	ITextSelection textSelection = textViewer.getLastKnownSelection();
	if (textSelection == null) {
		return Optional.empty();
	}
	int selectionLength = textSelection.getLength();
	if (selectionLength <= 0) {
		return Optional.empty();
	}

	try {
		int startOffset = textSelection.getOffset();
		Position startPosition = LSPEclipseUtils.toPosition(startOffset, document);
		int endOffset = startOffset + selectionLength;
		Position endPosition = LSPEclipseUtils.toPosition(endOffset, document);

		return Optional.of(new Range(startPosition, endPosition));
	} catch (BadLocationException e) {
		return Optional.empty();
	}
}